# Column

class Column<T>(val table: Table, val name: String, val columnType: IColumnType<T & Any>) : ExpressionWithColumnType<T> , DdlAware, Comparable<Column<*>>

Represents a column.

## Constructors

Column
Link copied to clipboard
constructor(table: Table, name: String, columnType: IColumnType<T & Any>)

## Properties

autoIncColumnType
Link copied to clipboard
val Column<*>.autoIncColumnType: AutoIncColumnType<*>?

Returns this column's type cast as AutoIncColumnType or `null` if the cast fails.

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

Data type of the column.

ddl
Link copied to clipboard
open val ddl: List<String>

Returns the list of DDL statements that create this DdlAware instance.

defaultValueFun
Link copied to clipboard
var defaultValueFun: () -> T?

Returns the function that calculates the default value for this column.

foreignKey
Link copied to clipboard
var foreignKey: ForeignKeyConstraint?

The foreign key constraint on this column, or `null` if the column is not referencing.

name
Link copied to clipboard
val name: String

Name of the column.

referee
Link copied to clipboard
val referee: Column<*>?

Returns the column that this column references.

table
Link copied to clipboard
val table: Table

Table where the columns are declared.

## 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>
autoGenerate
Link copied to clipboard
fun Column<UUID>.autoGenerate(): Column<UUID>

java.util.UUID column will auto generate its value on the client side just before an insert.

@JvmName(name = "autoGenerateKotlinUuid")
fun Column<Uuid>.autoGenerate(): Column<Uuid>

kotlin.uuid.Uuid column will auto generate its value on the client side just before an insert. By default, the new random Uuid instance will conform to the result of calling Uuid.generateV4.

fun Column<Uuid>.autoGenerate(uuidVersion: Table.UuidVersion): Column<Uuid>

kotlin.uuid.Uuid column will auto generate its value on the client side just before an insert. The new random Uuid instance will conform to the result of calling the Uuid companion method associated with the provided UuidVersion.

autoIncrement
Link copied to clipboard
fun <N : Any> Column<N>.autoIncrement(idSeqName: String? = null): Column<N>

Make @receiver column an auto-increment column to generate its values in a database. Note: Only integer and long columns are supported (signed and unsigned types). Some databases, like PostgreSQL, support auto-increment via sequences. In this case a name should be provided using the idSeqName param and Exposed will create a sequence. If a sequence already exists in the database just use its name in idSeqName.

fun <N : Any> Column<N>.autoIncrement(sequence: Sequence): Column<N>

Make @receiver column an auto-increment column to generate its values in a database. Note: Only integer and long columns are supported (signed and unsigned types). Some databases, like PostgreSQL, support auto-increment via sequences. In this case, a sequence should be provided using the sequence param.

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 : Any, E : EntityID<T>?> Column<E>.between(from: T, to: T): Between

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

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 : Any, E : EntityID<T>?> Column<E>.between(from: T, to: T): Between
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.

check
Link copied to clipboard
fun <T> Column<T>.check(name: String = "", op: (Column<T>) -> Op<Boolean>): Column<T>

Creates a check constraint in this column.

clientDefault
Link copied to clipboard
fun <T> Column<T>.clientDefault(defaultValue: () -> T): Column<T>

Sets the default value for this column in the client side.

comment
Link copied to clipboard
fun <T> Column<T>.comment(text: String): Column<T>

Adds a comment to this column that will be stored in the database schema.

compareTo
Link copied to clipboard
open operator override fun compareTo(other: Column<*>): Int
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.

countDistinct
Link copied to clipboard
fun Column<*>.countDistinct(): Count

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

createStatement
Link copied to clipboard
open override fun createStatement(): List<String>

Returns the list of DDL statements that create this object.

databaseGenerated
Link copied to clipboard
fun <T> Column<T>.databaseGenerated(): Column<T>

Marks a column as `databaseGenerated` if the default value of the column is not known at the time of table creation and/or if it depends on other columns. It makes it possible to omit setting it when inserting a new record, without getting an error. The value for the column can be set by creating a TRIGGER or with a DEFAULT clause or by using GENERATED ALWAYS AS via Column.withDefinition, for example.

default
Link copied to clipboard
fun <T> Column<T>.default(defaultValue: T): Column<T>

Sets the default value for this column in the database side.

defaultExpression
Link copied to clipboard
fun <T> Column<T>.defaultExpression(defaultValue: Expression<T>): Column<T>

Sets the default value for this column in the database side.

defaultValueInDb
Link copied to clipboard
fun defaultValueInDb(): Expression<T>?

Returns the default value for this column on the database-side.

descriptionDdl
Link copied to clipboard
fun descriptionDdl(modify: Boolean = false): String

Returns the SQL representation of this column.

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.

dropStatement
Link copied to clipboard
open override fun dropStatement(): List<String>

Returns the list of DDL statements that drops this object.

entityId
Link copied to clipboard
fun <T : Any> Column<T>.entityId(): Column<EntityID<T>>

Converts the @receiver column to an EntityID column.

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
@JvmName(name = "greaterEntityID")
infix fun <T : Comparable<T>> Column<EntityID<T>>.greater(t: T): GreaterOp

Checks if this EntityID expression is greater than some t value.

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.

@JvmName(name = "greaterEntityID")
open infix fun <T : Comparable<T>> Column<EntityID<T>>.greater(t: T): GreaterOp
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
@JvmName(name = "greaterEqEntityID")
infix fun <T : Comparable<T>> Column<EntityID<T>>.greaterEq(t: T): GreaterEqOp

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

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.

@JvmName(name = "greaterEqEntityID")
open infix fun <T : Comparable<T>> Column<EntityID<T>>.greaterEq(t: T): GreaterEqOp
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
index
Link copied to clipboard
fun <T> Column<T>.index(customIndexName: String? = null, isUnique: Boolean = false): Column<T>

Creates an index composed by this column only.

inList
Link copied to clipboard
@JvmName(name = "inListIds")
infix fun <T : Any, ID : EntityID<T>?> Column<ID>.inList(list: Iterable<T>): InListOrNotInListBaseOp<EntityID<T>?>
@JvmName(name = "inListCompositeEntityIds")
infix fun <ID : EntityID<CompositeID>> Column<ID>.inList(list: Iterable<CompositeID>): InListOrNotInListBaseOp<List<*>>

Checks if this EntityID column is equal to any element from list.

infix fun <T> ExpressionWithColumnType<T>.inList(list: Iterable<T>): InListOrNotInListBaseOp<T>

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

@JvmName(name = "inListIds")
open infix fun <T : Any, ID : EntityID<T>?> Column<ID>.inList(list: Iterable<T>): InListOrNotInListBaseOp<EntityID<T>?>
@JvmName(name = "inListCompositeEntityIds")
open infix fun <ID : EntityID<CompositeID>> Column<ID>.inList(list: Iterable<CompositeID>): InListOrNotInListBaseOp<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>
isDatabaseGenerated
Link copied to clipboard
fun isDatabaseGenerated(): Boolean

Returns whether this column's value will be generated in the database.

isDistinctFrom
Link copied to clipboard
@JvmName(name = "isDistinctFromEntityID")
infix fun <T : Any> Column<EntityID<T>>.isDistinctFrom(t: T): IsDistinctFromOp
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

@JvmName(name = "isDistinctFromEntityID")
open infix fun <T : Any> Column<EntityID<T>>.isDistinctFrom(t: T): IsDistinctFromOp
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
@JvmName(name = "isNotDistinctFromEntityID")
infix fun <T : Any> Column<EntityID<T>>.isNotDistinctFrom(t: T): IsNotDistinctFromOp
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

@JvmName(name = "isNotDistinctFromEntityID")
open infix fun <T : Any> Column<EntityID<T>>.isNotDistinctFrom(t: T): IsNotDistinctFromOp
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
@JvmName(name = "lessEntityID")
infix fun <T : Comparable<T>> Column<EntityID<T>>.less(t: T): LessOp

Checks if this EntityID expression is less than some t value.

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.

@JvmName(name = "lessEntityID")
open infix fun <T : Comparable<T>> Column<EntityID<T>>.less(t: T): LessOp
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
@JvmName(name = "lessEqEntityID")
infix fun <T : Comparable<T>> Column<EntityID<T>>.lessEq(t: T): LessEqOp

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

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.

@JvmName(name = "lessEqEntityID")
open infix fun <T : Comparable<T>> Column<EntityID<T>>.lessEq(t: T): LessEqOp
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>
modifyStatement
Link copied to clipboard
open override fun modifyStatement(): List<String>

Returns the list of DDL statements that modify this object.

modifyStatements
Link copied to clipboard
fun modifyStatements(columnDiff: ColumnDiff): List<String>

Returns the SQL statements that modify this column according to differences in the provided ColumnDiff.

nameInDatabaseCase
Link copied to clipboard
fun nameInDatabaseCase(): String

Returns the column name in proper case.

nameUnquoted
Link copied to clipboard
fun nameUnquoted(): String

Returns the column name with wrapping double-quotation characters removed.

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
@JvmName(name = "notInListIds")
infix fun <T : Any, ID : EntityID<T>?> Column<ID>.notInList(list: Iterable<T>): InListOrNotInListBaseOp<EntityID<T>?>
@JvmName(name = "notInListCompositeEntityIds")
infix fun <ID : EntityID<CompositeID>> Column<ID>.notInList(list: Iterable<CompositeID>): InListOrNotInListBaseOp<List<*>>

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

infix fun <T> ExpressionWithColumnType<T>.notInList(list: Iterable<T>): InListOrNotInListBaseOp<T>

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

@JvmName(name = "notInListIds")
open infix fun <T : Any, ID : EntityID<T>?> Column<ID>.notInList(list: Iterable<T>): InListOrNotInListBaseOp<EntityID<T>?>
@JvmName(name = "notInListCompositeEntityIds")
open infix fun <ID : EntityID<CompositeID>> Column<ID>.notInList(list: Iterable<CompositeID>): InListOrNotInListBaseOp<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>
nullable
Link copied to clipboard
fun <T : Any> Column<T>.nullable(): Column<T?>

Marks this column as nullable.

nullTransform
Link copied to clipboard
@JvmName(name = "nullTransform")
fun <Unwrapped : Any, Wrapped : Any> Column<Unwrapped>.nullTransform(transformer: ColumnTransformer<Unwrapped, Wrapped?>): Column<Wrapped?>
@JvmName(name = "nullTransform")
fun <Unwrapped : Any, Wrapped : Any> Column<Unwrapped>.nullTransform(wrap: (Unwrapped) -> Wrapped?, unwrap: (Wrapped?) -> Unwrapped): Column<Wrapped?>

Applies a special transformation that allows a non-nullable database column to accept and/or return values as `null` on the client side.

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
referee
Link copied to clipboard
fun <S : T> referee(): Column<S>?

Returns the column that this column references, cast as a column of type S, or `null` if the cast fails.

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 column to the specified queryBuilder.

toString
Link copied to clipboard
open override fun toString(): String
transform
Link copied to clipboard
@JvmName(name = "transformNullable")
fun <Unwrapped : Any, Wrapped : Any> Column<Unwrapped?>.transform(transformer: ColumnTransformer<Unwrapped?, Wrapped?>): Column<Wrapped?>

Transforms a nullable column by specifying a transformer.

fun <Unwrapped : Any, Wrapped : Any> Column<Unwrapped>.transform(transformer: ColumnTransformer<Unwrapped, Wrapped>): Column<Wrapped>

Transforms a column by specifying a transformer.

@JvmName(name = "transformNullable")
fun <Unwrapped : Any, Wrapped : Any> Column<Unwrapped?>.transform(wrap: (Unwrapped?) -> Wrapped?, unwrap: (Wrapped?) -> Unwrapped?): Column<Wrapped?>

Transforms a nullable column by specifying transformation functions.

fun <Unwrapped : Any, Wrapped : Any> Column<Unwrapped>.transform(wrap: (Unwrapped) -> Wrapped, unwrap: (Wrapped) -> Unwrapped): Column<Wrapped>

Transforms a column by specifying transformation functions.

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.

uniqueIndex
Link copied to clipboard
fun <T> Column<T>.uniqueIndex(customIndexName: String? = null): Column<T>

Creates a unique index composed by this column only.

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.

withColumnType
Link copied to clipboard
fun withColumnType(columnType: IColumnType<T & Any>): Column<T>

Returns a copy of this column, but with the given column type.

withDefinition
Link copied to clipboard
fun <T> Column<T>.withDefinition(vararg definition: Any): Column<T>

Appends a database-specific column definition to this column's SQL in a CREATE TABLE statement.

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>