# DivideOp

class DivideOp<T, S : T>(dividend: Expression<T>, divisor: Expression<S>, columnType: IColumnType<T & Any>) : CustomOperator<T>

Represents an SQL operator that divides expr1 by expr2.

## Constructors

DivideOp
Link copied to clipboard
constructor(dividend: Expression<T>, divisor: Expression<S>, columnType: IColumnType<T & Any>)

## Types

Companion
Link copied to clipboard
object Companion

## Properties

columnType
Link copied to clipboard
open override val columnType: IColumnType<T & Any>

Returns the column type of this expression. Used for operations with literals.

expr1
Link copied to clipboard
val expr1: Expression<*>

Returns the left-hand side operand.

expr2
Link copied to clipboard
val expr2: Expression<*>

Returns the right-hand side operand.

operatorName
Link copied to clipboard
val operatorName: String

Returns the name of the operator.

## Functions

alias
Link copied to clipboard
fun <T> ExpressionWithColumnType<T>.alias(alias: String): ExpressionWithColumnTypeAlias<T>

Creates a temporary identifier, alias, for this expression with column type.

fun <T> Expression<T>.alias(alias: String): ExpressionAlias<T>

Creates a temporary identifier, alias, for this expression.

and
Link copied to clipboard
inline fun Expression<Boolean>.and(op: () -> Op<Boolean>): Op<Boolean>
infix fun Expression<Boolean>.and(op: Expression<Boolean>): Op<Boolean>

Returns the result of performing a logical `and` operation between this expression and the op.

andNot
Link copied to clipboard
inline fun Expression<Boolean>.andNot(op: () -> Op<Boolean>): Op<Boolean>

Returns the result of performing a logical `and` operation between this expression and the negate op.

asLiteral
Link copied to clipboard
fun <T, S : T?> ExpressionWithColumnType<S>.asLiteral(value: T): LiteralOp<T>

Returns the specified value as a literal of type T.

open fun <T, S : T?> ExpressionWithColumnType<S>.asLiteral(value: T): LiteralOp<T>
avg
Link copied to clipboard
fun <T : Comparable<T>, S : T?> ExpressionWithColumnType<S>.avg(scale: Int = 2): Avg<T, S>

Returns the average (arithmetic mean) value of this expression across all non-null input values, or `null` if there are no non-null values.

between
Link copied to clipboard
fun <T, S : T?> ExpressionWithColumnType<in S>.between(from: T, to: T): Between

Returns `true` if this expression is between the values from and to, `false` otherwise.

open fun <T, S : T?> ExpressionWithColumnType<in S>.between(from: T, to: T): Between
bitwiseAnd
Link copied to clipboard
infix fun <T> ExpressionWithColumnType<T>.bitwiseAnd(t: T): AndBitOp<T, T>

Performs a bitwise `and` on this expression and t.

infix fun <T> ExpressionWithColumnType<T>.bitwiseAnd(t: Expression<T>): AndBitOp<T, T>

Performs a bitwise `and` on this expression and expression t.

open infix fun <T> ExpressionWithColumnType<T>.bitwiseAnd(t: T): AndBitOp<T, T>
open infix fun <T> ExpressionWithColumnType<T>.bitwiseAnd(t: Expression<T>): AndBitOp<T, T>
bitwiseOr
Link copied to clipboard
infix fun <T> ExpressionWithColumnType<T>.bitwiseOr(t: T): OrBitOp<T, T>

Performs a bitwise `or` on this expression and t.

infix fun <T> ExpressionWithColumnType<T>.bitwiseOr(t: Expression<T>): OrBitOp<T, T>

Performs a bitwise `or` on this expression and expression t.

open infix fun <T> ExpressionWithColumnType<T>.bitwiseOr(t: T): OrBitOp<T, T>
open infix fun <T> ExpressionWithColumnType<T>.bitwiseOr(t: Expression<T>): OrBitOp<T, T>
bitwiseXor
Link copied to clipboard
infix fun <T> ExpressionWithColumnType<T>.bitwiseXor(t: T): XorBitOp<T, T>

Performs a bitwise `or` on this expression and t.

infix fun <T> ExpressionWithColumnType<T>.bitwiseXor(t: Expression<T>): XorBitOp<T, T>

Performs a bitwise `or` on this expression and expression t.

open infix fun <T> ExpressionWithColumnType<T>.bitwiseXor(t: T): XorBitOp<T, T>
open infix fun <T> ExpressionWithColumnType<T>.bitwiseXor(t: Expression<T>): XorBitOp<T, T>
castTo
Link copied to clipboard
fun <R> Expression<*>.castTo(columnType: IColumnType<R & Any>): ExpressionWithColumnType<R>

Specifies a conversion from one data type to another.

charLength
Link copied to clipboard
fun <T : String?> Expression<T>.charLength(): CharLength<T>

Returns the length of this string expression, measured in characters, or `null` if this expression is null.

cosineDistance
Link copied to clipboard
fun <T> ExpressionWithColumnType<T>.cosineDistance(target: Expression<T>): VectorDistance<T>

Returns the mathematical distance calculated between the two vector expressions, based on cosine similarity.

fun ExpressionWithColumnType<FloatArray>.cosineDistance(target: FloatArray): VectorDistance<FloatArray>
fun ExpressionWithColumnType<IntArray>.cosineDistance(target: IntArray): VectorDistance<IntArray>

Returns the mathematical distance calculated between this vector expression and a target vector, based on cosine similarity.

count
Link copied to clipboard
fun ExpressionWithColumnType<*>.count(): Count

Returns the number of input rows for which the value of this expression is not null.

div
Link copied to clipboard
infix operator fun <T> ExpressionWithColumnType<T>.div(t: T): DivideOp<T, T>

Divides this expression by the t value.

infix operator fun <T, S : T> ExpressionWithColumnType<T>.div(other: Expression<S>): DivideOp<T, S>

Divides this expression by the other expression.

open infix operator fun <T> ExpressionWithColumnType<T>.div(t: T): DivideOp<T, T>
open infix operator fun <T, S : T> ExpressionWithColumnType<T>.div(other: Expression<S>): DivideOp<T, S>
dotDistance
Link copied to clipboard
fun <T> ExpressionWithColumnType<T>.dotDistance(target: Expression<T>): VectorDistance<T>

Returns the mathematical distance calculated between the two vector expressions, based on dot product similarity.

fun ExpressionWithColumnType<FloatArray>.dotDistance(target: FloatArray): VectorDistance<FloatArray>
fun ExpressionWithColumnType<IntArray>.dotDistance(target: IntArray): VectorDistance<IntArray>

Returns the mathematical distance calculated between this vector expression and a target vector, based on dot product similarity.

eq
Link copied to clipboard
infix fun <T> ExpressionWithColumnType<T>.eq(t: T): Op<Boolean>

Checks if this expression is equal to some t value.

@JvmName(name = "eqEntityIDValue")
infix fun <T : Any, E : EntityID<T>?, V : T?> ExpressionWithColumnType<E>.eq(t: V): Op<Boolean>

Checks if this EntityID expression is equal to some t value.

infix fun <T : Any, E : EntityID<T>?, V : T?> ExpressionWithColumnType<E>.eq(other: Expression<V>): Op<Boolean>

Checks if this EntityID expression is equal to some other expression.

infix fun <T, S1 : T?, S2 : T?> Expression<in S1>.eq(other: Expression<in S2>): Op<Boolean>

Checks if this expression is equal to some other expression.

infix fun <T : Any, V : T?, E : EntityID<T>?> Expression<V>.eq(other: ExpressionWithColumnType<E>): Op<Boolean>

Checks if this expression is equal to some other expression.

open infix fun <T> ExpressionWithColumnType<T>.eq(t: T): Op<Boolean>
@JvmName(name = "eqEntityIDValue")
open infix fun <T : Any, E : EntityID<T>?, V : T?> ExpressionWithColumnType<E>.eq(t: V): Op<Boolean>
open infix fun <T : Any, E : EntityID<T>?, V : T?> ExpressionWithColumnType<E>.eq(other: Expression<V>): Op<Boolean>
open infix fun <T, S1 : T?, S2 : T?> Expression<in S1>.eq(other: Expression<in S2>): Op<Boolean>
open infix fun <T : Any, V : T?, E : EntityID<T>?> Expression<V>.eq(other: ExpressionWithColumnType<E>): Op<Boolean>
eqSubQuery
Link copied to clipboard
infix fun <T> Expression<T>.eqSubQuery(query: AbstractQuery<*>): EqSubQueryOp<T>

Checks if this expression is equals to single value returned from query.

open infix fun <T> Expression<T>.eqSubQuery(query: AbstractQuery<*>): EqSubQueryOp<T>
equals
Link copied to clipboard
open operator override fun equals(other: Any?): Boolean
euclideanDistance
Link copied to clipboard
fun <T> ExpressionWithColumnType<T>.euclideanDistance(target: Expression<T>): VectorDistance<T>

Returns the mathematical distance calculated between the two vector expressions, based on euclidean similarity.

fun ExpressionWithColumnType<FloatArray>.euclideanDistance(target: FloatArray): VectorDistance<FloatArray>
fun ExpressionWithColumnType<IntArray>.euclideanDistance(target: IntArray): VectorDistance<IntArray>

Returns the mathematical distance calculated between this vector expression and a target vector, based on euclidean similarity.

firstValue
Link copied to clipboard
fun <T> ExpressionWithColumnType<T>.firstValue(): FirstValue<T>

Returns value evaluated at the row that is the first row of the window frame.

open fun <T> ExpressionWithColumnType<T>.firstValue(): FirstValue<T>
function
Link copied to clipboard
fun <T> ExpressionWithColumnType<T>.function(functionName: String): CustomFunction<T?>

Calls a custom SQL function with the specified functionName and passes this expression as its only argument.

get
Link copied to clipboard
infix operator fun <E, T : List<E>?> ExpressionWithColumnType<T>.get(index: Int): ArrayGet<E, T>

Returns the array element stored at the one-based index position, or `null` if the stored array itself is null.

greater
Link copied to clipboard
infix fun <T : Comparable<T>, S : T?> ExpressionWithColumnType<in S>.greater(t: T): GreaterOp

Checks if this expression is greater than some t value.

infix fun <T : Comparable<T>, E : EntityID<T>?, V : T?> ExpressionWithColumnType<E>.greater(other: Expression<in V>): GreaterOp

Checks if this EntityID expression is greater than some other expression.

infix fun <T : Comparable<T>, V : T?, E : EntityID<T>?> Expression<V>.greater(other: ExpressionWithColumnType<E>): GreaterOp

Checks if this expression is greater than some other expression.

infix fun <T : Comparable<T>, S : T?> Expression<in S>.greater(other: Expression<in S>): GreaterOp

Checks if this expression is greater than some other expression.

@JvmName(name = "greaterBetweenEntityIDs")
infix fun <T : Comparable<T>, E : EntityID<T>?> Expression<E>.greater(other: Expression<E>): GreaterOp

Checks if this EntityID expression is greater than some other expression.

open infix fun <T : Comparable<T>, S : T?> ExpressionWithColumnType<in S>.greater(t: T): GreaterOp
open infix fun <T : Comparable<T>, E : EntityID<T>?, V : T?> ExpressionWithColumnType<E>.greater(other: Expression<in V>): GreaterOp
open infix fun <T : Comparable<T>, V : T?, E : EntityID<T>?> Expression<V>.greater(other: ExpressionWithColumnType<E>): GreaterOp
open infix fun <T : Comparable<T>, S : T?> Expression<in S>.greater(other: Expression<in S>): GreaterOp
@JvmName(name = "greaterBetweenEntityIDs")
open infix fun <T : Comparable<T>, E : EntityID<T>?> Expression<E>.greater(other: Expression<E>): GreaterOp
greaterEq
Link copied to clipboard
infix fun <T : Comparable<T>, S : T?> ExpressionWithColumnType<in S>.greaterEq(t: T): GreaterEqOp

Checks if this expression is greater than or equal to some t value

infix fun <T : Comparable<T>, E : EntityID<T>?, V : T?> ExpressionWithColumnType<E>.greaterEq(other: Expression<in V>): GreaterEqOp

Checks if this EntityID expression is greater than or equal to some other expression

infix fun <T : Comparable<T>, V : T?, E : EntityID<T>?> Expression<V>.greaterEq(other: ExpressionWithColumnType<E>): GreaterEqOp

Checks if this expression is greater than or equal to some other expression.

infix fun <T : Comparable<T>, S : T?> Expression<in S>.greaterEq(other: Expression<in S>): GreaterEqOp

Checks if this expression is greater than or equal to some other expression

@JvmName(name = "greaterEqBetweenEntityIDs")
infix fun <T : Comparable<T>, E : EntityID<T>?> Expression<E>.greaterEq(other: Expression<E>): GreaterEqOp

Checks if this EntityID expression is greater than or equal to some other expression.

open infix fun <T : Comparable<T>, S : T?> ExpressionWithColumnType<in S>.greaterEq(t: T): GreaterEqOp
open infix fun <T : Comparable<T>, E : EntityID<T>?, V : T?> ExpressionWithColumnType<E>.greaterEq(other: Expression<in V>): GreaterEqOp
open infix fun <T : Comparable<T>, V : T?, E : EntityID<T>?> Expression<V>.greaterEq(other: ExpressionWithColumnType<E>): GreaterEqOp
open infix fun <T : Comparable<T>, S : T?> Expression<in S>.greaterEq(other: Expression<in S>): GreaterEqOp
@JvmName(name = "greaterEqBetweenEntityIDs")
open infix fun <T : Comparable<T>, E : EntityID<T>?> Expression<E>.greaterEq(other: Expression<E>): GreaterEqOp
greaterEqSubQuery
Link copied to clipboard
infix fun <T> Expression<T>.greaterEqSubQuery(query: AbstractQuery<*>): GreaterEqSubQueryOp<T>

Checks if this expression is greater than or equal to the single value returned from query.

open infix fun <T> Expression<T>.greaterEqSubQuery(query: AbstractQuery<*>): GreaterEqSubQueryOp<T>
greaterSubQuery
Link copied to clipboard
infix fun <T> Expression<T>.greaterSubQuery(query: AbstractQuery<*>): GreaterSubQueryOp<T>

Checks if this expression is greater than the single value returned from query.

open infix fun <T> Expression<T>.greaterSubQuery(query: AbstractQuery<*>): GreaterSubQueryOp<T>
groupConcat
Link copied to clipboard
fun <T : String?> Expression<T>.groupConcat(separator: String? = null, distinct: Boolean = false, orderBy: Array<Pair<Expression<*>, SortOrder>> = emptyArray()): GroupConcat<T>
fun <T : String?> Expression<T>.groupConcat(separator: String? = null, distinct: Boolean = false, orderBy: Pair<Expression<*>, SortOrder>): GroupConcat<T>

Concatenates all non-null input values of each group from this string expression, separated by separator.

hasFlag
Link copied to clipboard
infix fun <T> ExpressionWithColumnType<T>.hasFlag(t: T): EqOp

Performs a bitwise `and` on this expression and t.

infix fun <T> ExpressionWithColumnType<T>.hasFlag(t: Expression<T>): EqOp

Performs a bitwise `and` on this expression and expression t.

open infix fun <T> ExpressionWithColumnType<T>.hasFlag(t: T): EqOp
open infix fun <T> ExpressionWithColumnType<T>.hasFlag(t: Expression<T>): EqOp
hashCode
Link copied to clipboard
open override fun hashCode(): Int
inList
Link copied to clipboard
infix fun <T> ExpressionWithColumnType<T>.inList(list: Iterable<T>): InListOrNotInListBaseOp<T>

Checks if this expression is equal to any element from list.

open infix fun <T> ExpressionWithColumnType<T>.inList(list: Iterable<T>): InListOrNotInListBaseOp<T>
inSubQuery
Link copied to clipboard
infix fun <T> Expression<T>.inSubQuery(query: AbstractQuery<*>): InSubQueryOp<T>

Checks if this expression is equals to any row returned from query.

open infix fun <T> Expression<T>.inSubQuery(query: AbstractQuery<*>): InSubQueryOp<T>
inTable
Link copied to clipboard
infix fun <T> ExpressionWithColumnType<T>.inTable(table: Table): InTableOp

Checks if this expression is equal to any element from the column of table with only a single column.

open infix fun <T> ExpressionWithColumnType<T>.inTable(table: Table): InTableOp
intToDecimal
Link copied to clipboard
fun ExpressionWithColumnType<Int>.intToDecimal(): NoOpConversion<Int, BigDecimal>

Changes this integer expression to a BigDecimal type.

open fun ExpressionWithColumnType<Int>.intToDecimal(): NoOpConversion<Int, BigDecimal>
isDistinctFrom
Link copied to clipboard
infix fun <T : Comparable<T>, S : T?> ExpressionWithColumnType<in S>.isDistinctFrom(t: T): IsDistinctFromOp

Checks if this expression is not equal to some t value, with `null` treated as a comparable value

infix fun <T : Any, E : EntityID<T>?, V : T?> ExpressionWithColumnType<E>.isDistinctFrom(other: Expression<in V>): IsDistinctFromOp

Checks if this EntityID expression is not equal to some other expression

infix fun <T : Any, V : T?, E : EntityID<T>?> Expression<in V>.isDistinctFrom(other: ExpressionWithColumnType<E>): IsDistinctFromOp

Checks if this expression is not equal to some other expression.

infix fun <T : Comparable<T>, S : T?> Expression<in S>.isDistinctFrom(other: Expression<in S>): IsDistinctFromOp

Checks if this expression is not equal to some other expression, with `null` treated as a comparable value

open infix fun <T : Comparable<T>, S : T?> ExpressionWithColumnType<in S>.isDistinctFrom(t: T): IsDistinctFromOp
open infix fun <T : Any, E : EntityID<T>?, V : T?> ExpressionWithColumnType<E>.isDistinctFrom(other: Expression<in V>): IsDistinctFromOp
open infix fun <T : Any, V : T?, E : EntityID<T>?> Expression<in V>.isDistinctFrom(other: ExpressionWithColumnType<E>): IsDistinctFromOp
open infix fun <T : Comparable<T>, S : T?> Expression<in S>.isDistinctFrom(other: Expression<in S>): IsDistinctFromOp
isNotDistinctFrom
Link copied to clipboard
infix fun <T : Comparable<T>, S : T?> ExpressionWithColumnType<in S>.isNotDistinctFrom(t: T): IsNotDistinctFromOp

Checks if this expression is equal to some t value, with `null` treated as a comparable value

infix fun <T : Any, E : EntityID<T>?, V : T?> ExpressionWithColumnType<E>.isNotDistinctFrom(other: Expression<in V>): IsNotDistinctFromOp

Checks if this EntityID expression is equal to some other expression

infix fun <T : Any, V : T?, E : EntityID<T>?> Expression<V>.isNotDistinctFrom(other: ExpressionWithColumnType<E>): IsNotDistinctFromOp

Checks if this expression is equal to some other expression.

infix fun <T : Comparable<T>, S : T?> Expression<in S>.isNotDistinctFrom(other: Expression<in S>): IsNotDistinctFromOp

Checks if this expression is equal to some other expression, with `null` treated as a comparable value

open infix fun <T : Comparable<T>, S : T?> ExpressionWithColumnType<in S>.isNotDistinctFrom(t: T): IsNotDistinctFromOp
open infix fun <T : Any, E : EntityID<T>?, V : T?> ExpressionWithColumnType<E>.isNotDistinctFrom(other: Expression<in V>): IsNotDistinctFromOp
open infix fun <T : Any, V : T?, E : EntityID<T>?> Expression<V>.isNotDistinctFrom(other: ExpressionWithColumnType<E>): IsNotDistinctFromOp
open infix fun <T : Comparable<T>, S : T?> Expression<in S>.isNotDistinctFrom(other: Expression<in S>): IsNotDistinctFromOp
isNotNull
Link copied to clipboard
fun <T> Expression<T>.isNotNull(): Op<Boolean>

Returns `true` if this expression is not null, `false` otherwise.

open fun <T> Expression<T>.isNotNull(): Op<Boolean>
isNull
Link copied to clipboard
fun <T> Expression<T>.isNull(): Op<Boolean>

Returns `true` if this expression is null, `false` otherwise.

open fun <T> Expression<T>.isNull(): Op<Boolean>
isNullOrEmpty
Link copied to clipboard
fun <T : String?> Expression<T>.isNullOrEmpty(): Op<Boolean>

Returns `true` if this string expression is null or empty, `false` otherwise.

open fun <T : String?> Expression<T>.isNullOrEmpty(): Op<Boolean>
lag
Link copied to clipboard
fun <T> ExpressionWithColumnType<T>.lag(offset: ExpressionWithColumnType<Int> = intLiteral(1), defaultValue: ExpressionWithColumnType<T>? = null): Lag<T>

Returns value evaluated at the row that is offset rows before the current row within the partition; if there is no such row, instead returns defaultValue. Both offset and defaultValue are evaluated with respect to the current row.

open fun <T> ExpressionWithColumnType<T>.lag(offset: ExpressionWithColumnType<Int> = intLiteral(1), defaultValue: ExpressionWithColumnType<T>? = null): Lag<T>
lastValue
Link copied to clipboard
fun <T> ExpressionWithColumnType<T>.lastValue(): LastValue<T>

Returns value evaluated at the row that is the last row of the window frame.

open fun <T> ExpressionWithColumnType<T>.lastValue(): LastValue<T>
lead
Link copied to clipboard
fun <T> ExpressionWithColumnType<T>.lead(offset: ExpressionWithColumnType<Int> = intLiteral(1), defaultValue: ExpressionWithColumnType<T>? = null): Lead<T>

Returns value evaluated at the row that is offset rows after the current row within the partition; if there is no such row, instead returns defaultValue. Both offset and defaultValue are evaluated with respect to the current row.

open fun <T> ExpressionWithColumnType<T>.lead(offset: ExpressionWithColumnType<Int> = intLiteral(1), defaultValue: ExpressionWithColumnType<T>? = null): Lead<T>
less
Link copied to clipboard
infix fun <T : Comparable<T>, S : T?> ExpressionWithColumnType<in S>.less(t: T): LessOp

Checks if this expression is less than some t value.

infix fun <T : Comparable<T>, E : EntityID<T>?, V : T?> ExpressionWithColumnType<E>.less(other: Expression<in V>): LessOp

Checks if this EntityID expression is less than some other expression.

infix fun <T : Comparable<T>, V : T?, E : EntityID<T>?> Expression<V>.less(other: ExpressionWithColumnType<E>): LessOp

Checks if this expression is less than some other expression.

infix fun <T : Comparable<T>, S : T?> Expression<in S>.less(other: Expression<in S>): LessOp

Checks if this expression is less than some other expression.

@JvmName(name = "lessBetweenEntityIDs")
infix fun <T : Comparable<T>, E : EntityID<T>?> Expression<E>.less(other: Expression<E>): LessOp

Checks if this EntityID expression is less than some other expression.

open infix fun <T : Comparable<T>, S : T?> ExpressionWithColumnType<in S>.less(t: T): LessOp
open infix fun <T : Comparable<T>, E : EntityID<T>?, V : T?> ExpressionWithColumnType<E>.less(other: Expression<in V>): LessOp
open infix fun <T : Comparable<T>, V : T?, E : EntityID<T>?> Expression<V>.less(other: ExpressionWithColumnType<E>): LessOp
open infix fun <T : Comparable<T>, S : T?> Expression<in S>.less(other: Expression<in S>): LessOp
@JvmName(name = "lessBetweenEntityIDs")
open infix fun <T : Comparable<T>, E : EntityID<T>?> Expression<E>.less(other: Expression<E>): LessOp
lessEq
Link copied to clipboard
infix fun <T : Comparable<T>, S : T?> ExpressionWithColumnType<in S>.lessEq(t: T): LessEqOp

Checks if this expression is less than or equal to some t value

infix fun <T : Comparable<T>, E : EntityID<T>?, V : T?> ExpressionWithColumnType<E>.lessEq(other: Expression<in V>): LessEqOp

Checks if this EntityID expression is less than or equal to some other expression

infix fun <T : Comparable<T>, V : T?, E : EntityID<T>?> Expression<V>.lessEq(other: ExpressionWithColumnType<E>): LessEqOp

Checks if this expression is less than or equal to some other expression.

infix fun <T : Comparable<T>, S : T?> Expression<in S>.lessEq(other: Expression<in S>): LessEqOp

Checks if this expression is less than or equal to some other expression

@JvmName(name = "lessEqBetweenEntityIDs")
infix fun <T : Comparable<T>, E : EntityID<T>?> Expression<E>.lessEq(other: Expression<E>): LessEqOp

Checks if this EntityID expression is less than or equal to some other expression.

open infix fun <T : Comparable<T>, S : T?> ExpressionWithColumnType<in S>.lessEq(t: T): LessEqOp
open infix fun <T : Comparable<T>, E : EntityID<T>?, V : T?> ExpressionWithColumnType<E>.lessEq(other: Expression<in V>): LessEqOp
open infix fun <T : Comparable<T>, V : T?, E : EntityID<T>?> Expression<V>.lessEq(other: ExpressionWithColumnType<E>): LessEqOp
open infix fun <T : Comparable<T>, S : T?> Expression<in S>.lessEq(other: Expression<in S>): LessEqOp
@JvmName(name = "lessEqBetweenEntityIDs")
open infix fun <T : Comparable<T>, E : EntityID<T>?> Expression<E>.lessEq(other: Expression<E>): LessEqOp
lessEqSubQuery
Link copied to clipboard
infix fun <T> Expression<T>.lessEqSubQuery(query: AbstractQuery<*>): LessEqSubQueryOp<T>

Checks if this expression is less than or equal to the single value returned from query.

open infix fun <T> Expression<T>.lessEqSubQuery(query: AbstractQuery<*>): LessEqSubQueryOp<T>
lessSubQuery
Link copied to clipboard
infix fun <T> Expression<T>.lessSubQuery(query: AbstractQuery<*>): LessSubQueryOp<T>

Checks if this expression is less than the single value returned from query.

open infix fun <T> Expression<T>.lessSubQuery(query: AbstractQuery<*>): LessSubQueryOp<T>
like
Link copied to clipboard
infix fun <T : String?> Expression<T>.like(pattern: String): LikeEscapeOp
infix fun <T : String?> Expression<T>.like(pattern: LikePattern): LikeEscapeOp
@JvmName(name = "likeWithEntityID")
infix fun Expression<EntityID<String>>.like(pattern: String): LikeEscapeOp
@JvmName(name = "likeWithEntityID")
infix fun Expression<EntityID<String>>.like(pattern: LikePattern): LikeEscapeOp

Checks if this expression matches the specified pattern.

infix fun <T : String?> Expression<T>.like(expression: ExpressionWithColumnType<String>): LikeEscapeOp
@JvmName(name = "likeWithEntityIDAndExpression")
infix fun Expression<EntityID<String>>.like(expression: ExpressionWithColumnType<String>): LikeEscapeOp

Checks if this expression matches the specified expression.

open infix fun <T : String?> Expression<T>.like(pattern: String): LikeEscapeOp
open infix fun <T : String?> Expression<T>.like(expression: ExpressionWithColumnType<String>): LikeEscapeOp
open infix fun <T : String?> Expression<T>.like(pattern: LikePattern): LikeEscapeOp
@JvmName(name = "likeWithEntityID")
open infix fun Expression<EntityID<String>>.like(pattern: String): LikeEscapeOp
@JvmName(name = "likeWithEntityIDAndExpression")
open infix fun Expression<EntityID<String>>.like(expression: ExpressionWithColumnType<String>): LikeEscapeOp
@JvmName(name = "likeWithEntityID")
open infix fun Expression<EntityID<String>>.like(pattern: LikePattern): LikeEscapeOp
locate
Link copied to clipboard
fun <T : String?> Expression<T>.locate(substring: String): Locate<T>

Returns the index of the first occurrence of substring in this string expression or 0 if it doesn't contain substring

lowerCase
Link copied to clipboard
fun <T : String?> Expression<T>.lowerCase(): LowerCase<T>

Converts this string expression to lower case.

match
Link copied to clipboard
infix fun <T : String?> Expression<T>.match(pattern: String): Op<Boolean>

Checks if this expression matches the specified pattern.

fun <T : String?> Expression<T>.match(pattern: String, mode: FunctionProvider.MatchMode?): Op<Boolean>

Checks if this expression matches the specified pattern using the specified match mode.

open infix fun <T : String?> Expression<T>.match(pattern: String): Op<Boolean>
open fun <T : String?> Expression<T>.match(pattern: String, mode: FunctionProvider.MatchMode?): Op<Boolean>
max
Link copied to clipboard
fun <T : Any, S : T?> ExpressionWithColumnType<in S>.max(): Max<T, S>

Returns the maximum value of this expression across all non-null input values, or `null` if there are no non-null values.

min
Link copied to clipboard
fun <T : Any, S : T?> ExpressionWithColumnType<in S>.min(): Min<T, S>

Returns the minimum value of this expression across all non-null input values, or `null` if there are no non-null values.

minus
Link copied to clipboard
infix operator fun <T> ExpressionWithColumnType<T>.minus(t: T): MinusOp<T, T>

Subtracts the t value from this expression.

infix operator fun <T, S : T> ExpressionWithColumnType<T>.minus(other: Expression<S>): MinusOp<T, S>

Subtracts the other expression from this expression.

open infix operator fun <T> ExpressionWithColumnType<T>.minus(t: T): MinusOp<T, T>
open infix operator fun <T, S : T> ExpressionWithColumnType<T>.minus(other: Expression<S>): MinusOp<T, S>
mod
Link copied to clipboard
infix fun <T : Number?, S : T> ExpressionWithColumnType<T>.mod(t: S): ModOp<T, S, T>

Calculates the remainder of dividing this expression by the t value.

infix fun <T : Number?, S : Number> ExpressionWithColumnType<T>.mod(other: Expression<S>): ModOp<T, S, T>

Calculates the remainder of dividing this expression by the other expression.

@JvmName(name = "modWithEntityId")
infix fun <T : Number, Comparable<T>, S : Number, ID : EntityID<T>?> ExpressionWithColumnType<ID>.mod(other: S): ExpressionWithColumnType<T>

Calculates the remainder of dividing the value of this numeric PK by the other number.

@JvmName(name = "modWithEntityId3")
infix fun <T : Number, Comparable<T>, S : Number, ID : EntityID<T>?> ExpressionWithColumnType<ID>.mod(other: Expression<S>): ExpressionWithColumnType<T>

Calculates the remainder of dividing the value of this numeric PK by the other number expression.

@JvmName(name = "modWithEntityId2")
infix fun <T : Number, Comparable<T>, S : Number, ID : EntityID<T>?> Expression<S>.mod(other: ExpressionWithColumnType<ID>): ExpressionWithColumnType<T>

Calculates the remainder of dividing this number expression by other numeric PK

open infix fun <T : Number?, S : T> ExpressionWithColumnType<T>.mod(t: S): ModOp<T, S, T>
open infix fun <T : Number?, S : Number> ExpressionWithColumnType<T>.mod(other: Expression<S>): ModOp<T, S, T>
@JvmName(name = "modWithEntityId")
open infix fun <T : Number, Comparable<T>, S : Number, ID : EntityID<T>?> ExpressionWithColumnType<ID>.mod(other: S): ExpressionWithColumnType<T>
@JvmName(name = "modWithEntityId3")
open infix fun <T : Number, Comparable<T>, S : Number, ID : EntityID<T>?> ExpressionWithColumnType<ID>.mod(other: Expression<S>): ExpressionWithColumnType<T>
@JvmName(name = "modWithEntityId2")
open infix fun <T : Number, Comparable<T>, S : Number, ID : EntityID<T>?> Expression<S>.mod(other: ExpressionWithColumnType<ID>): ExpressionWithColumnType<T>
neq
Link copied to clipboard
infix fun <T> ExpressionWithColumnType<T>.neq(other: T): Op<Boolean>

Checks if this expression is not equal to some other value.

@JvmName(name = "neqEntityIDValue")
infix fun <T : Any, E : EntityID<T>?, V : T?> ExpressionWithColumnType<E>.neq(t: V): Op<Boolean>

Checks if this EntityID expression is not equal to some t value.

infix fun <T : Any, E : EntityID<T>?, V : T?> ExpressionWithColumnType<E>.neq(other: Expression<V>): Op<Boolean>

Checks if this EntityID expression is not equal to some other expression.

infix fun <T, S1 : T?, S2 : T?> Expression<in S1>.neq(other: Expression<in S2>): Op<Boolean>

Checks if this expression is not equal to some other expression.

infix fun <T : Any, V : T?, E : EntityID<T>?> Expression<V>.neq(other: ExpressionWithColumnType<E>): Op<Boolean>

Checks if this expression is not equal to some other expression.

open infix fun <T> ExpressionWithColumnType<T>.neq(other: T): Op<Boolean>
@JvmName(name = "neqEntityIDValue")
open infix fun <T : Any, E : EntityID<T>?, V : T?> ExpressionWithColumnType<E>.neq(t: V): Op<Boolean>
open infix fun <T : Any, E : EntityID<T>?, V : T?> ExpressionWithColumnType<E>.neq(other: Expression<V>): Op<Boolean>
open infix fun <T, S1 : T?, S2 : T?> Expression<in S1>.neq(other: Expression<in S2>): Op<Boolean>
open infix fun <T : Any, V : T?, E : EntityID<T>?> Expression<V>.neq(other: ExpressionWithColumnType<E>): Op<Boolean>
notEqSubQuery
Link copied to clipboard
infix fun <T> Expression<T>.notEqSubQuery(query: AbstractQuery<*>): NotEqSubQueryOp<T>

Checks if this expression is not equals to single value returned from query.

open infix fun <T> Expression<T>.notEqSubQuery(query: AbstractQuery<*>): NotEqSubQueryOp<T>
notInList
Link copied to clipboard
infix fun <T> ExpressionWithColumnType<T>.notInList(list: Iterable<T>): InListOrNotInListBaseOp<T>

Checks if this expression is not equal to any element from list.

open infix fun <T> ExpressionWithColumnType<T>.notInList(list: Iterable<T>): InListOrNotInListBaseOp<T>
notInSubQuery
Link copied to clipboard
infix fun <T> Expression<T>.notInSubQuery(query: AbstractQuery<*>): NotInSubQueryOp<T>

Checks if this expression is not equals to any row returned from query.

open infix fun <T> Expression<T>.notInSubQuery(query: AbstractQuery<*>): NotInSubQueryOp<T>
notInTable
Link copied to clipboard
infix fun <T> ExpressionWithColumnType<T>.notInTable(table: Table): InTableOp

Checks if this expression is not equal to any element from the column of table with only a single column.

open infix fun <T> ExpressionWithColumnType<T>.notInTable(table: Table): InTableOp
notLike
Link copied to clipboard
infix fun <T : String?> Expression<T>.notLike(pattern: String): LikeEscapeOp
infix fun <T : String?> Expression<T>.notLike(pattern: LikePattern): LikeEscapeOp
@JvmName(name = "notLikeWithEntityID")
infix fun Expression<EntityID<String>>.notLike(pattern: String): LikeEscapeOp
@JvmName(name = "notLikeWithEntityID")
infix fun Expression<EntityID<String>>.notLike(pattern: LikePattern): LikeEscapeOp

Checks if this expression doesn't match the specified pattern.

infix fun <T : String?> Expression<T>.notLike(expression: ExpressionWithColumnType<String>): LikeEscapeOp

Checks if this expression doesn't match the specified pattern.

@JvmName(name = "notLikeWithEntityIDAndExpression")
infix fun Expression<EntityID<String>>.notLike(expression: ExpressionWithColumnType<String>): LikeEscapeOp

Checks if this expression doesn't match the specified expression.

open infix fun <T : String?> Expression<T>.notLike(pattern: String): LikeEscapeOp
open infix fun <T : String?> Expression<T>.notLike(expression: ExpressionWithColumnType<String>): LikeEscapeOp
open infix fun <T : String?> Expression<T>.notLike(pattern: LikePattern): LikeEscapeOp
@JvmName(name = "notLikeWithEntityID")
open infix fun Expression<EntityID<String>>.notLike(pattern: String): LikeEscapeOp
@JvmName(name = "notLikeWithEntityIDAndExpression")
open infix fun Expression<EntityID<String>>.notLike(expression: ExpressionWithColumnType<String>): LikeEscapeOp
@JvmName(name = "notLikeWithEntityID")
open infix fun Expression<EntityID<String>>.notLike(pattern: LikePattern): LikeEscapeOp
nthValue
Link copied to clipboard
fun <T> ExpressionWithColumnType<T>.nthValue(n: ExpressionWithColumnType<Int>): NthValue<T>

Returns value evaluated at the row that is the n'th row of the window frame (counting from 1); null if no such row.

open fun <T> ExpressionWithColumnType<T>.nthValue(n: ExpressionWithColumnType<Int>): NthValue<T>
or
Link copied to clipboard
inline fun Expression<Boolean>.or(op: () -> Op<Boolean>): Op<Boolean>
infix fun Expression<Boolean>.or(op: Expression<Boolean>): Op<Boolean>

Returns the result of performing a logical `or` operation between this expression and the op.

orNot
Link copied to clipboard
inline fun Expression<Boolean>.orNot(op: () -> Op<Boolean>): Op<Boolean>

Returns the result of performing a logical `or` operation between this expression and the negate op.

plus
Link copied to clipboard
infix operator fun <T> ExpressionWithColumnType<T>.plus(t: T): PlusOp<T, T>

Adds the t value to this expression.

infix operator fun <T, S : T> ExpressionWithColumnType<T>.plus(other: Expression<S>): PlusOp<T, S>

Adds the other expression to this expression.

infix operator fun Expression<String>.plus(value: String): Concat
infix operator fun Expression<String>.plus(value: Expression<String>): Concat

Concatenate the value to the input expression.

open infix operator fun <T> ExpressionWithColumnType<T>.plus(t: T): PlusOp<T, T>
open infix operator fun <T, S : T> ExpressionWithColumnType<T>.plus(other: Expression<S>): PlusOp<T, S>
open infix operator fun Expression<String>.plus(value: String): Concat
open infix operator fun Expression<String>.plus(value: Expression<String>): Concat
regexp
Link copied to clipboard
infix fun <T : String?> Expression<T>.regexp(pattern: String): RegexpOp<T>
fun <T : String?> Expression<T>.regexp(pattern: Expression<String>, caseSensitive: Boolean = true): RegexpOp<T>

Checks if this expression matches the pattern. Supports regular expressions.

open infix fun <T : String?> Expression<T>.regexp(pattern: String): RegexpOp<T>
open fun <T : String?> Expression<T>.regexp(pattern: Expression<String>, caseSensitive: Boolean = true): RegexpOp<T>
rem
Link copied to clipboard
infix operator fun <T : Number?, S : T> ExpressionWithColumnType<T>.rem(t: S): ModOp<T, S, T>

Calculates the remainder of dividing this expression by the t value.

infix operator fun <T : Number?, S : Number> ExpressionWithColumnType<T>.rem(other: Expression<S>): ModOp<T, S, T>

Calculates the remainder of dividing this expression by the other expression.

@JvmName(name = "remWithEntityId")
infix operator fun <T : Number, Comparable<T>, S : Number, ID : EntityID<T>?> ExpressionWithColumnType<ID>.rem(other: S): ExpressionWithColumnType<T>

Calculates the remainder of dividing the value of this numeric PK by the other number.

@JvmName(name = "remWithEntityId3")
infix operator fun <T : Number, Comparable<T>, S : Number, ID : EntityID<T>?> ExpressionWithColumnType<ID>.rem(other: Expression<S>): ExpressionWithColumnType<T>

Calculates the remainder of dividing the value of this numeric PK by the other number expression.

@JvmName(name = "remWithEntityId2")
infix operator fun <T : Number, Comparable<T>, S : Number, ID : EntityID<T>?> Expression<S>.rem(other: ExpressionWithColumnType<ID>): ExpressionWithColumnType<T>

Calculates the remainder of dividing this number expression by other numeric PK

open infix operator fun <T : Number?, S : T> ExpressionWithColumnType<T>.rem(t: S): ModOp<T, S, T>
open infix operator fun <T : Number?, S : Number> ExpressionWithColumnType<T>.rem(other: Expression<S>): ModOp<T, S, T>
@JvmName(name = "remWithEntityId")
open infix operator fun <T : Number, Comparable<T>, S : Number, ID : EntityID<T>?> ExpressionWithColumnType<ID>.rem(other: S): ExpressionWithColumnType<T>
@JvmName(name = "remWithEntityId3")
open infix operator fun <T : Number, Comparable<T>, S : Number, ID : EntityID<T>?> ExpressionWithColumnType<ID>.rem(other: Expression<S>): ExpressionWithColumnType<T>
@JvmName(name = "remWithEntityId2")
open infix operator fun <T : Number, Comparable<T>, S : Number, ID : EntityID<T>?> Expression<S>.rem(other: ExpressionWithColumnType<ID>): ExpressionWithColumnType<T>
slice
Link copied to clipboard
fun <E, T : List<E>?> ExpressionWithColumnType<T>.slice(lower: Int? = null, upper: Int? = null): ArraySlice<E, T>

Returns a subarray of elements stored from between lower and upper bounds (inclusive), or `null` if the stored array itself is null. Note If either bounds is left `null`, the database will use the stored array's respective lower or upper limit.

stdDevPop
Link copied to clipboard
fun <T> ExpressionWithColumnType<T>.stdDevPop(scale: Int = 2): StdDevPop<T>

Returns the population standard deviation of the non-null input values, or `null` if there are no non-null values.

stdDevSamp
Link copied to clipboard
fun <T> ExpressionWithColumnType<T>.stdDevSamp(scale: Int = 2): StdDevSamp<T>

Returns the sample standard deviation of the non-null input values, or `null` if there are no non-null values.

substring
Link copied to clipboard
fun <T : String?> Expression<T>.substring(start: Int, length: Int): Substring<T>

Extract a substring from this string expression that begins at the specified start and with the specified length.

sum
Link copied to clipboard
fun <T> ExpressionWithColumnType<T>.sum(): Sum<T>

Returns the sum of this expression across all non-null input values, or `null` if there are no non-null values.

times
Link copied to clipboard
infix operator fun <T> ExpressionWithColumnType<T>.times(t: T): TimesOp<T, T>

Multiplies this expression by the t value.

infix operator fun <T, S : T> ExpressionWithColumnType<T>.times(other: Expression<S>): TimesOp<T, S>

Multiplies this expression by the other expression.

open infix operator fun <T> ExpressionWithColumnType<T>.times(t: T): TimesOp<T, T>
open infix operator fun <T, S : T> ExpressionWithColumnType<T>.times(other: Expression<S>): TimesOp<T, S>
toQueryBuilder
Link copied to clipboard
open override fun toQueryBuilder(queryBuilder: QueryBuilder)

Appends the SQL representation of this expression to the specified queryBuilder.

toString
Link copied to clipboard
open override fun toString(): String
trim
Link copied to clipboard
fun <T : String?> Expression<T>.trim(): Trim<T>

Removes the longest string containing only spaces from both ends of string expression.

upperCase
Link copied to clipboard
fun <T : String?> Expression<T>.upperCase(): UpperCase<T>

Converts this string expression to upper case.

varPop
Link copied to clipboard
fun <T> ExpressionWithColumnType<T>.varPop(scale: Int = 2): VarPop<T>

Returns the population variance of the non-null input values (square of the population standard deviation), or `null` if there are no non-null values.

varSamp
Link copied to clipboard
fun <T> ExpressionWithColumnType<T>.varSamp(scale: Int = 2): VarSamp<T>

Returns the sample variance of the non-null input values (square of the sample standard deviation), or `null` if there are no non-null values.

withScale
Link copied to clipboard
fun <T : BigDecimal?, S : T> DivideOp<T, S>.withScale(scale: Int): DivideOp<T, S>
wrap
Link copied to clipboard
fun <T, S : T?> ExpressionWithColumnType<in S>.wrap(value: T): QueryParameter<T>

Returns the specified value as a query parameter of type T.

open fun <T, S : T?> ExpressionWithColumnType<in S>.wrap(value: T): QueryParameter<T>