# Query

open class Query(var set: FieldSet, where: Op<Boolean>?) : AbstractQuery<Query>

Class representing an SQL `SELECT` statement on which query clauses can be built.

## Constructors

Query
Link copied to clipboard
constructor(set: FieldSet, where: Op<Boolean>?)

## Types

CommentPosition
Link copied to clipboard
enum CommentPosition : Enum<Query.CommentPosition>

Represents the position at which an SQL comment will be added in a `SELECT` query.

## Properties

comments
Link copied to clipboard
var comments: Map<Query.CommentPosition, String>

The stored comments and their CommentPositions in this `SELECT` query.

distinct
Link copied to clipboard
var distinct: Boolean

Whether only distinct results should be retrieved by this `SELECT` query.

distinctOn
Link copied to clipboard
var distinctOn: List<Column<*>>?

List of columns on which the query should be distinct.

fetchSize
Link copied to clipboard
var fetchSize: Int?

The number of results that should be fetched when this query is executed.

groupedByColumns
Link copied to clipboard
var groupedByColumns: List<Expression<*>>

The stored list of columns for a `GROUP BY` clause in this `SELECT` query.

having
Link copied to clipboard
var having: Op<Boolean>?

The stored condition for a `HAVING` clause in this `SELECT` query.

isAlwaysBatch
Link copied to clipboard
open val isAlwaysBatch: Boolean

Whether the SQL statement is meant to be performed as part of a batch execution.

limit
Link copied to clipboard
var limit: Int?

The stored value for a `LIMIT` clause in this query.

offset
Link copied to clipboard
var offset: Long

The stored value for an `OFFSET` clause in this query.

orderByExpressions
Link copied to clipboard
var orderByExpressions: List<Pair<Expression<*>, SortOrder>>

The stored list of columns and their SortOrder for an `ORDER BY` clause in this query.

set
Link copied to clipboard
open override var set: FieldSet

The set of columns on which a query should be executed, contained by a ColumnSet.

targets
Link copied to clipboard
val targets: List<Table>
type
Link copied to clipboard
val type: StatementType
where
Link copied to clipboard
var where: Op<Boolean>?

The stored condition for a `WHERE` clause in this `SELECT` query.

## Functions

adjustColumnSet
Link copied to clipboard
inline fun adjustColumnSet(body: ColumnSet.() -> ColumnSet): Query

Assigns a new column set, either a Table or a Join, by changing the `source` property of this query's set, while preserving its `fields` property.

adjustComments
Link copied to clipboard
fun adjustComments(position: Query.CommentPosition, content: String? = null): Query

Changes the content of the comments field at the specified position in this query.

adjustHaving
Link copied to clipboard
fun adjustHaving(body: Op<Boolean>?.() -> Op<Boolean>): Query

Changes the having field of this query.

adjustSelect
Link copied to clipboard
inline fun adjustSelect(body: ColumnSet.(FieldSet) -> Query): Query

Assigns a new selection of columns, by changing the `fields` property of this query's set, while preserving its `source` property.

adjustSlice
Link copied to clipboard
fun adjustSlice(body: ColumnSet.(FieldSet) -> FieldSet): Query
adjustWhere
Link copied to clipboard
fun adjustWhere(body: Op<Boolean>?.() -> Op<Boolean>): Query

Changes the where field of this query.

andHaving
Link copied to clipboard
fun Query.andHaving(andPart: SqlExpressionBuilder.() -> Op<Boolean>): Query

Mutate Query instance and add `andPart` to having condition with `and` operator.

andWhere
Link copied to clipboard
fun Query.andWhere(andPart: SqlExpressionBuilder.() -> Op<Boolean>): Query

Mutate Query instance and add `andPart` to where condition with `and` operator.

appendTo
Link copied to clipboard
fun <T> Iterable<T>.appendTo(builder: QueryBuilder, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", transform: QueryBuilder.(T) -> Unit): QueryBuilder

Appends all the elements separated using separator and using the given prefix and postfix if supplied.

arguments
Link copied to clipboard
open override fun arguments(): List<List<Pair<IColumnType<*>, Any?>>>

Returns all mappings of columns and expression types to their values needed to prepare an SQL statement.

comment
Link copied to clipboard
fun comment(content: String, position: Query.CommentPosition = CommentPosition.FRONT): Query

Appends an SQL comment, with content wrapped by `/* */`, at the specified CommentPosition in this `SELECT` query.

copy
Link copied to clipboard
open override fun copy(): Query

Creates a new Query instance using all stored properties of this `SELECT` query.

copyTo
Link copied to clipboard
open override fun copyTo(other: Query)

Copies all stored properties of this `SELECT` query into the properties of other.

count
Link copied to clipboard
open override fun count(): Long

Returns the number of results retrieved after query execution.

empty
Link copied to clipboard
open override fun empty(): Boolean

Returns whether any results were retrieved by query execution.

except
Link copied to clipboard
fun AbstractQuery<*>.except(other: Query): Except

Returns only distinct results from this query that are NOT common to the results of other.

execute
Link copied to clipboard
fun execute(transaction: Transaction): ResultSet?

Executes the SQL statement directly in the provided transaction and returns the generated result, or `null` if either no result was retrieved or if the transaction blocked statement execution.

executeInternal
Link copied to clipboard
open override fun PreparedStatementApi.executeInternal(transaction: Transaction): ResultSet?

Determines the exact way that an SQL statement is executed in a transaction and applies any necessary logic before returning the result generated by the executed statement.

fetchBatchedResults
Link copied to clipboard
fun fetchBatchedResults(batchSize: Int = 1000, sortOrder: SortOrder = SortOrder.ASC): Iterable<Iterable<ResultRow>>

Iterates over multiple executions of this `SELECT` query with its `LIMIT` clause set to batchSize until the amount of results retrieved from the database is less than batchSize.

fetchSize
Link copied to clipboard
fun fetchSize(n: Int): Query

Modifies the number of results that should be fetched when this query is executed.

forEach
Link copied to clipboard
open fun forEach(p0: Consumer<in ResultRow>)
forUpdate
Link copied to clipboard
open override fun forUpdate(option: ForUpdateOption): Query

Returns a new SizedIterable with a locking read for the elements according to the rules specified by option.

groupBy
Link copied to clipboard
fun groupBy(vararg columns: Expression<*>): Query

Appends a `GROUP BY` clause with the specified columns to this `SELECT` query.

hasCustomForUpdateState
Link copied to clipboard
fun hasCustomForUpdateState(): Boolean

Whether this `SELECT` query already has a stored value option for performing locking reads.

having
Link copied to clipboard
fun having(op: SqlExpressionBuilder.() -> Op<Boolean>): Query

Appends a `HAVING` clause with the specified op condition to this `SELECT` query.

intersect
Link copied to clipboard
fun AbstractQuery<*>.intersect(other: Query): Intersect

Returns only results from this query that are common to the results of other, WITHOUT including any duplicates.

isForUpdate
Link copied to clipboard
fun isForUpdate(): Boolean

Whether this `SELECT` query will perform a locking read.

iterator
Link copied to clipboard
open operator override fun iterator(): Iterator<ResultRow>
limit
Link copied to clipboard
open override fun limit(count: Int): Query

Modifies this query to return only count results.

open override fun limit(n: Int, offset: Long): Query
mapLazy
Link copied to clipboard
infix fun <T, R> SizedIterable<T>.mapLazy(f: (T) -> R): SizedIterable<R>

Returns a SizedIterable containing the lazily evaluated results of applying the function f to each original element.

notForUpdate
Link copied to clipboard
open override fun notForUpdate(): Query

Returns a new SizedIterable without any locking read for the elements.

offset
Link copied to clipboard
open override fun offset(start: Long): Query

Modifies this query to return only results starting after the specified start.

orderBy
Link copied to clipboard
open override fun orderBy(vararg order: Pair<Expression<*>, SortOrder>): Query

Modifies this query to sort results according to the provided order of expressions.

fun orderBy(column: Expression<*>, order: SortOrder = SortOrder.ASC): Query

Modifies this query to sort results by the specified column, according to the provided order.

orHaving
Link copied to clipboard
fun Query.orHaving(orPart: SqlExpressionBuilder.() -> Op<Boolean>): Query

Mutate Query instance and add `orPart` to having condition with `or` operator.

orWhere
Link copied to clipboard
fun Query.orWhere(orPart: SqlExpressionBuilder.() -> Op<Boolean>): Query

Mutate Query instance and add `orPart` to where condition with `or` operator.

prepared
Link copied to clipboard
open fun prepared(transaction: Transaction, sql: String): PreparedStatementApi

Uses a transaction connection and an sql string representation to return a precompiled SQL statement, stored as an implementation of PreparedStatementApi.

prepareSQL
Link copied to clipboard
open override fun prepareSQL(transaction: Transaction, prepared: Boolean): String

Returns the string representation of an SQL statement.

open override fun prepareSQL(builder: QueryBuilder): String

Returns the string representation of an SQL query, generated by appending SQL expressions to a QueryBuilder.

select
Link copied to clipboard
inline fun Query.select(where: SqlExpressionBuilder.() -> Op<Boolean>): Query
fun Query.select(where: Op<Boolean>): Query
selectAllBatched
Link copied to clipboard
fun Query.selectAllBatched(batchSize: Int = 1000): Iterable<Iterable<ResultRow>>
selectBatched
Link copied to clipboard
fun Query.selectBatched(batchSize: Int = 1000, where: SqlExpressionBuilder.() -> Op<Boolean>): Iterable<Iterable<ResultRow>>
spliterator
Link copied to clipboard
open fun spliterator(): Spliterator<ResultRow>
union
Link copied to clipboard
fun AbstractQuery<*>.union(other: Query): Union

Combines all results from this query with the results of other, WITHOUT including duplicates.

unionAll
Link copied to clipboard
fun AbstractQuery<*>.unionAll(other: Query): UnionAll

Combines all results from this query with the results of other, WITH duplicates included.

where
Link copied to clipboard
fun where(predicate: SqlExpressionBuilder.() -> Op<Boolean>): Query
fun where(predicate: Op<Boolean>): Query

Appends a `WHERE` clause with the specified predicate to this `SELECT` query.

withDistinct
Link copied to clipboard
open override fun withDistinct(value: Boolean): Query

Modifies this query to retrieve only distinct results if value is set to `true`.

withDistinctOn
Link copied to clipboard
fun withDistinctOn(vararg columns: Pair<Column<*>, SortOrder>): Query

Specifies that the `SELECT` query should retrieve distinct results based on the given list of columns with sort orders. This method sets a `DISTINCT ON` clause and may reorder the results as indicated.

fun withDistinctOn(vararg columns: Column<*>): Query

Specifies that the `SELECT` query should retrieve distinct results based on the given list of columns.