data class Tuple9<out T1, out T2, out T3, out T4, out T5, out T6, out T7, out T8, out T9>(_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9)

Functions

all

fun <T : Any> all(subQuery: TypedSubQuery<T>): Expression<T>

and

fun and(vararg predicates: NonNullExpression<Boolean>?): NonNullExpression<Boolean>?

any

fun <T : Any> any(subQuery: TypedSubQuery<T>): Expression<T>

avg

fun <T : Number> Expression<T>.avg(): Expression<T>

between

fun <T : Comparable<T>> Expression<T>.between(min: T, max: T): NonNullExpression<Boolean>

fun <T : Comparable<T>> Expression<T>.between(min: Expression<T>, max: Expression<T>): NonNullExpression<Boolean>

case

fun case(): CaseStartBuilder

fun <C : Any> case(expression: Expression<C>): SimpleCaseStartBuilder<C>

coalesce

fun <T : Any> coalesce(expression: Expression<T>): CoalesceBuilder<T>

fun <T : Any> coalesce(expression: NonNullExpression<T>): NonNullCoalesceBuilder<T>

fun <T : Any> coalesce(expression: Expression<T>, defaultValue: T): NonNullExpression<T>

concat

fun concat(first: NonNullExpression<String>, vararg others: NonNullExpression<String>): NonNullExpression<String>

constant

fun <T : Number> constant(value: T): NonNullExpression<T>

count

fun Expression<*>.count(distinct: Boolean = false): NonNullExpression<Long>

div

operator fun <T : Number> Expression<T>.div(value: T): Expression<T>

operator fun <T : Number> Expression<T>.div(other: Expression<T>): Expression<T>

operator fun <T : Number> NonNullExpression<T>.div(value: T): NonNullExpression<T>

operator fun <T : Number> NonNullExpression<T>.div(other: Expression<T>): NonNullExpression<T>

infix fun <T : Any> Expression<T>.eq(value: T): NonNullExpression<Boolean>

infix fun <T : Any> Expression<T>.eq(other: Expression<T>): NonNullExpression<Boolean>

exists

fun exists(subQuery: MutableSubQuery<*, *, *, *>): NonNullExpression<Boolean>

fun exists(subQuery: TypedSubQuery<*>): NonNullExpression<Boolean>

infix fun <T : Comparable<T>> Expression<T>.ge(value: T): NonNullExpression<Boolean>

infix fun <T : Comparable<T>> Expression<T>.ge(other: Expression<T>): NonNullExpression<Boolean>

infix fun <T : Comparable<T>> Expression<T>.gt(value: T): NonNullExpression<Boolean>

infix fun <T : Comparable<T>> Expression<T>.gt(other: Expression<T>): NonNullExpression<Boolean>

ilike

infix fun Expression<String>.ilike(value: String): NonNullExpression<Boolean>

fun Expression<String>.ilike(value: String, likeMode: LikeMode): NonNullExpression<Boolean>

isNotNull

fun Expression<*>.isNotNull(): NonNullExpression<Boolean>

isNull

fun Expression<*>.isNull(): NonNullExpression<Boolean>

infix fun <T : Comparable<T>> Expression<T>.le(value: T): NonNullExpression<Boolean>

infix fun <T : Comparable<T>> Expression<T>.le(other: Expression<T>): NonNullExpression<Boolean>

infix fun Expression<String>.like(value: String): NonNullExpression<Boolean>

fun Expression<String>.like(value: String, likeMode: LikeMode): NonNullExpression<Boolean>

infix fun <T : Comparable<T>> Expression<T>.lt(value: T): NonNullExpression<Boolean>

infix fun <T : Comparable<T>> Expression<T>.lt(other: Expression<T>): NonNullExpression<Boolean>

max

fun <T : Number> Expression<T>.max(): Expression<T>

min

fun <T : Number> Expression<T>.min(): Expression<T>

minus

operator fun <T : Number> Expression<T>.minus(value: T): Expression<T>

operator fun <T : Number> Expression<T>.minus(other: Expression<T>): Expression<T>

operator fun <T : Number> NonNullExpression<T>.minus(value: T): NonNullExpression<T>

operator fun <T : Number> NonNullExpression<T>.minus(other: Expression<T>): NonNullExpression<T>

infix fun <T : Any> Expression<T>.ne(value: T): NonNullExpression<Boolean>

infix fun <T : Any> Expression<T>.ne(other: Expression<T>): NonNullExpression<Boolean>

not

fun not(predicate: NonNullExpression<Boolean>?): NonNullExpression<Boolean>?

notExists

fun notExists(subQuery: MutableSubQuery<*, *, *, *>): NonNullExpression<Boolean>

fun notExists(subQuery: TypedSubQuery<*>): NonNullExpression<Boolean>

nullValue

fun <T : Any> nullValue(type: KClass<T>): Expression<T>

fun or(vararg predicates: NonNullExpression<Boolean>?): NonNullExpression<Boolean>?

plus

operator fun <T : Number> Expression<T>.plus(value: T): Expression<T>

operator fun <T : Number> Expression<T>.plus(other: Expression<T>): Expression<T>

operator fun <T : Number> NonNullExpression<T>.plus(value: T): NonNullExpression<T>

operator fun <T : Number> NonNullExpression<T>.plus(other: NonNullExpression<T>): NonNullExpression<T>

rem

operator fun <T : Number> Expression<T>.rem(value: T): Expression<T>

operator fun <T : Number> Expression<T>.rem(other: Expression<T>): Expression<T>

operator fun <T : Number> NonNullExpression<T>.rem(value: T): NonNullExpression<T>

operator fun <T : Number> NonNullExpression<T>.rem(other: Expression<T>): NonNullExpression<T>

some

fun <T : Any> some(subQuery: TypedSubQuery<T>): Expression<T>

sql

fun <X : Any> sql(type: KClass<X>, sql: String, block: SqlExpressionBuilder.() -> Unit? = null): NonNullExpression<X>

sum

fun <T : Number> Expression<T>.sum(): Expression<T>

times

operator fun <T : Number> Expression<T>.times(value: T): Expression<T>

operator fun <T : Number> Expression<T>.times(other: Expression<T>): Expression<T>

operator fun <T : Number> NonNullExpression<T>.times(value: T): NonNullExpression<T>

operator fun <T : Number> NonNullExpression<T>.times(other: Expression<T>): NonNullExpression<T>

tuple

fun <T : Any> tuple(block: ProjectionContext.() -> Projection<T>): NonNullExpression<T>

unaryMinus

operator fun <T : Number> Expression<T>.unaryMinus(): Expression<T>

operator fun <T : Number> NonNullExpression<T>.unaryMinus(): NonNullExpression<T>

unaryPlus

operator fun <T : Number> Expression<T>.unaryPlus(): Expression<T>

operator fun <T : Number> NonNullExpression<T>.unaryPlus(): NonNullExpression<T>

value

fun <T : Any> value(value: T): NonNullExpression<T>

valueIn

infix fun <T : Any> Expression<T>.valueIn(values: Collection<T>): NonNullExpression<Boolean>

infix fun <T : Any> Expression<T>.valueIn(subQuery: TypedSubQuery<T>): NonNullExpression<Boolean>

valueNotIn

infix fun <T : Any> Expression<T>.valueNotIn(values: Collection<T>): NonNullExpression<Boolean>

infix fun <T : Any> Expression<T>.valueNotIn(subQuery: TypedSubQuery<T>): NonNullExpression<Boolean>