exposed-vertx-sql-client-crud/com.huanshankeji.exposedvertxsqlclient.crud

Package-level declarations

Functions

suspend fun <T : Table, E> DatabaseClient<*>.batchInsert(table: T, data: Iterable<E>, body: T.(InsertStatement<Number>, E) -> Unit): Sequence<Int>

batchInsertIgnore

suspend fun <T : Table, E> DatabaseClient<*>.batchInsertIgnore(table: T, data: Iterable<E>, body: T.(UpdateBuilder<*>, E) -> Unit): Sequence<Boolean>

batchInsertSelect

suspend fun DatabaseClient<*>.~~batchInsertSelect~~(statements: Iterable<InsertSelectStatement>): Sequence<Int>

This function is not conventional and its usages are likely to degrade performance.

batchSelect

suspend fun <T : ColumnSet, E> DatabaseClient<*>.~~batchSelect~~(columnSet: T, data: Iterable<E>, buildQuery: T.(E) -> Query): Sequence<RowSet<ResultRow>>

suspend fun <E> DatabaseClient<*>.batchSelect(data: Iterable<E>, buildQuery: (E) -> Query, getFieldExpressionSetWithExposedTransaction: Boolean = config.autoExposedTransaction): Sequence<RowSet<ResultRow>>

This function may be very rarely used, as eq conditions of multiple statements can usually be combined into an inList or eq select query.

batchSingleOrNoUpdate

suspend fun <T : Table, E> DatabaseClient<*>.batchSingleOrNoUpdate(table: T, data: Iterable<E>, where: (E) -> Op<Boolean>, limit: Int? = null, body: T.(UpdateStatement, E) -> Unit): Sequence<Boolean>

batchUpdate

suspend fun <T : Table, E> DatabaseClient<*>.batchUpdate(table: T, data: Iterable<E>, where: (E) -> Op<Boolean>, limit: Int? = null, body: T.(UpdateStatement, E) -> Unit): Sequence<Int>

deleteIgnoreWhere

suspend fun <T : Table> DatabaseClient<*>.deleteIgnoreWhere(table: T, limit: Int? = null, op: T.() -> Op<Boolean>): Int

suspend fun <T : Table> DatabaseClient<*>.~~deleteIgnoreWhere~~(table: T, limit: Int? = null, offset: Long? = null, op: T.() -> Op<Boolean>): Int

deleteWhere

suspend fun <T : Table> DatabaseClient<*>.deleteWhere(table: T, limit: Int? = null, op: T.() -> Op<Boolean>): Int

suspend fun <T : Table> DatabaseClient<*>.~~deleteWhere~~(table: T, limit: Int? = null, offset: Long? = null, op: T.() -> Op<Boolean>): Int

executeInsertIgnore

suspend fun <T : Table> DatabaseClient<*>.~~executeInsertIgnore~~(table: T, body: T.(UpdateBuilder<*>) -> Unit): Boolean

insert

suspend fun <T : Table> DatabaseClient<*>.insert(table: T, body: T.(InsertStatement<Number>) -> Unit)

suspend fun <T : Table> DatabaseClient<*>.insert(table: T, selectQuery: AbstractQuery<*>, columns: List<Column<*>>? = null, createStatementWithExposedTransaction: Boolean = config.autoExposedTransaction || columns == null): Int

insertIgnore

suspend fun <T : Table> DatabaseClient<*>.insertIgnore(table: T, body: T.(UpdateBuilder<*>) -> Unit): Boolean

suspend fun <T : Table> DatabaseClient<*>.insertIgnore(table: T, selectQuery: AbstractQuery<*>, columns: List<Column<*>>? = null, createStatementWithExposedTransaction: Boolean = config.autoExposedTransaction || columns == null): Int

insertIgnoreSelect

suspend fun <T : Table> DatabaseClient<*>.insertIgnoreSelect(table: T, selectQuery: AbstractQuery<*>, columns: List<Column<*>>? = null, createStatementWithExposedTransaction: Boolean = config.autoExposedTransaction || columns == null): Int

An alias of the INSERT SELECT overload of insertIgnore.

insertIgnoreSingle

suspend fun <T : Table> DatabaseClient<*>.~~insertIgnoreSingle~~(table: T, body: T.(UpdateBuilder<*>) -> Unit): Boolean

insertSelect

suspend fun <T : Table> DatabaseClient<*>.insertSelect(table: T, selectQuery: AbstractQuery<*>, columns: List<Column<*>>? = null, createStatementWithExposedTransaction: Boolean = config.autoExposedTransaction || columns == null): Int

An alias of the INSERT SELECT overload of insert.

insertSingle

suspend fun <T : Table> DatabaseClient<*>.~~insertSingle~~(table: T, body: T.(InsertStatement<Number>) -> Unit)

select

inline suspend fun DatabaseClient<*>.select(columnSet: ColumnSet, buildQuery: ColumnSet.() -> Query, getFieldExpressionSetWithExposedTransaction: Boolean = config.autoExposedTransaction): RowSet<ResultRow>

inline suspend fun <Data> DatabaseClient<*>.select(columnSet: ColumnSet, buildQuery: ColumnSet.() -> Query, getFieldExpressionSetWithExposedTransaction: Boolean = config.autoExposedTransaction, crossinline resultRowMapper: ResultRow.() -> Data): RowSet<Data>

selectBatch

suspend fun <E> DatabaseClient<*>.~~selectBatch~~(fieldSet: FieldSet, buildQuery: FieldSet.(E) -> Query, data: Iterable<E>): Sequence<RowSet<ResultRow>>

selectColumnSetExpression

suspend fun <T> DatabaseClient<*>.~~selectColumnSetExpression~~(columnSet: ColumnSet, expression: Expression<T>, buildQuery: Query.() -> Query, getFieldExpressionSetWithExposedTransaction: Boolean = config.autoExposedTransaction): RowSet<T>

selectExpression

inline suspend fun <T> DatabaseClient<*>.selectExpression(expression: Expression<T>): T

suspend fun <T> DatabaseClient<*>.selectExpression(type: KClass<T & Any>, expression: Expression<T>): T

SQL: SELECT <expression>; without FROM in the outermost/top-level statement. Example: SELECT EXISTS(<query>).

inline suspend fun <T> DatabaseClient<*>.selectExpression(columnSet: ColumnSet, expression: Expression<T>, noinline buildQuery: Query.() -> Query): RowSet<T>

suspend fun <T> DatabaseClient<*>.selectExpression(type: KClass<T & Any>, columnSet: ColumnSet, expression: Expression<T>, buildQuery: Query.() -> Query): RowSet<T>

suspend fun <T> DatabaseClient<*>.~~selectExpression~~(columnSet: ColumnSet, expression: Expression<T>, buildQuery: Query.() -> Query, getFieldExpressionSetWithExposedTransaction: Boolean = config.autoExposedTransaction): RowSet<T>

SQL: SELECT <expression> FROM <table>;. Examples: SELECT COUNT(*) FROM <table>;, SELECT SUM(<column>) FROM <table>;.

selectSingleColumn

suspend fun <T> DatabaseClient<*>.~~selectSingleColumn~~(columnSet: ColumnSet, column: Column<T>, buildQuery: Query.() -> Query, getFieldExpressionSetWithExposedTransaction: Boolean = config.autoExposedTransaction): RowSet<T>

inline suspend fun <ColumnT, DataT> DatabaseClient<*>.~~selectSingleColumn~~(columnSet: ColumnSet, column: Column<ColumnT>, buildQuery: Query.() -> Query, getFieldExpressionSetWithExposedTransaction: Boolean = config.autoExposedTransaction, crossinline mapper: ColumnT.() -> DataT): RowSet<DataT>

selectSingleEntityIdColumn

suspend fun <T : Comparable<T>> DatabaseClient<*>.selectSingleEntityIdColumn(columnSet: ColumnSet, column: Column<EntityID<T>>, buildQuery: Query.() -> Query, getFieldExpressionSetWithExposedTransaction: Boolean = config.autoExposedTransaction): RowSet<T>

sortDataAndBatchUpdate

suspend fun <T : Table, E, SelectorResultT : Comparable<SelectorResultT>> DatabaseClient<*>.sortDataAndBatchUpdate(table: T, data: Iterable<E>, selector: (E) -> SelectorResultT, where: (E) -> Op<Boolean>, limit: Int? = null, body: T.(UpdateStatement, E) -> Unit): Sequence<Int>

update

suspend fun <T : Table> DatabaseClient<*>.update(table: T, where: () -> Op<Boolean>? = null, limit: Int? = null, body: T.(UpdateStatement) -> Unit): Int