exposed-vertx-sql-client-core/com.huanshankeji.exposedvertxsqlclient/DatabaseClient

DatabaseClient

class DatabaseClient<out VertxSqlClientT : SqlClient>(val vertxSqlClient: VertxSqlClientT, val config: DatabaseClientConfig) : CoroutineAutoCloseable, StatementPreparationExposedTransactionProvider(source)

The main entry point for executing database operations using Vert.x SQL Client with Exposed SQL generation.

This client wraps a Vert.x SqlClient for reactive query execution and uses Exposed for SQL generation, combining the type-safe SQL DSL of Exposed with the reactive, non-blocking capabilities of Vert.x.

Parameters

VertxSqlClientT

the type of Vert.x SQL client, which can be SqlClient, Pool, or SqlConnection or one of its database-specific subtypes.

vertxSqlClient

the Vert.x SQL client used for executing queries.

config

the configuration for this client, including SQL transformation, transaction settings, and the transaction provider for SQL statement preparation.

Constructors

DatabaseClient

constructor(vertxSqlClient: VertxSqlClientT, config: DatabaseClientConfig)

constructor(vertxSqlClient: VertxSqlClientT, exposedDatabase: Database, config: DatabaseClientConfig)

Secondary constructor that accepts a Database for backward compatibility.

Types

Companion

object Companion

Properties

config

val config: DatabaseClientConfig

exposedDatabase

val ~~exposedDatabase~~: Database

The Exposed Database used for SQL generation.

vertxSqlClient

val vertxSqlClient: VertxSqlClientT

Functions

open suspend override fun ~~close~~()

createTable

suspend fun ~~createTable~~(table: Table): Int

doExecute

suspend fun <SqlResultT : SqlResult<*>> ~~doExecute~~(statement: Statement<*>, transformQuery: PreparedQuery<RowSet<Row>>.() -> PreparedQuery<SqlResultT>): SqlResultT

dropTable

suspend fun ~~dropTable~~(table: Table): Int

execute

suspend fun <SqlResultT : SqlResult<*>> execute(statement: Statement<*>, transformQuery: PreparedQuery<RowSet<Row>>.() -> PreparedQuery<SqlResultT>): SqlResultT

executeBatch

suspend fun <SqlResultT : SqlResult<*>> executeBatch(statements: Iterable<Statement<*>>, transformQuery: PreparedQuery<RowSet<Row>>.() -> PreparedQuery<SqlResultT>): Sequence<SqlResultT>

executeBatchForVertxSqlClientRowSetSequence

suspend fun executeBatchForVertxSqlClientRowSetSequence(statements: Iterable<Statement<*>>): Sequence<RowSet<Row>>

executeBatchQuery

suspend fun executeBatchQuery(queries: Iterable<Query>, getFieldExpressionSetWithExposedTransaction: Boolean = config.autoExposedTransaction): Sequence<RowSet<ResultRow>>

See the KDoc of the overload with resultRowMapper parameter.

suspend fun ~~executeBatchQuery~~(fieldSet: FieldSet, queries: Iterable<Query>): Sequence<RowSet<ResultRow>>

inline suspend fun <Data> executeBatchQuery(queries: Iterable<Query>, getFieldExpressionSetWithExposedTransaction: Boolean = config.autoExposedTransaction, crossinline resultRowMapper: ResultRow.() -> Data): Sequence<RowSet<Data>>

inline suspend fun <Data> ~~executeBatchQuery~~(fieldSet: FieldSet, queries: Iterable<Query>, getFieldExpressionSetWithExposedTransaction: Boolean = config.autoExposedTransaction, crossinline resultRowMapper: ResultRow.() -> Data): Sequence<RowSet<Data>>

executeBatchUpdate

suspend fun executeBatchUpdate(statements: Iterable<Statement<Int>>): Sequence<Int>

Executes a batch of update statements, including InsertStatement and UpdateStatement.

executeExpression

inline suspend fun <T> ~~executeExpression~~(expression: Expression<T>): T

suspend fun <T : Any> ~~executeExpression~~(clazz: KClass<T>, expression: Expression<T?>): T?

executeForVertxSqlClientRowSet

suspend fun executeForVertxSqlClientRowSet(statement: Statement<*>): RowSet<Row>

executePlainSql

suspend fun executePlainSql(sql: String): RowSet<Row>

Use SqlClient.preparedQuery here because of SqlConnectOptions.setCachePreparedStatements.

executePlainSqlUpdate

suspend fun executePlainSqlUpdate(sql: String): Int

executeQuery

suspend fun executeQuery(query: Query, getFieldExpressionSetWithExposedTransaction: Boolean = config.autoExposedTransaction): RowSet<ResultRow>

inline suspend fun <Data> executeQuery(query: Query, getFieldExpressionSetWithExposedTransaction: Boolean = config.autoExposedTransaction, crossinline resultRowMapper: ResultRow.() -> Data): RowSet<Data>

executeQueryForList

suspend fun executeQueryForList(query: Query, getFieldExpressionSetWithExposedTransaction: Boolean = config.autoExposedTransaction): List<ResultRow>

An alternative API to executeQuery that returns a List instead of a RowSet.

executeSingleOrNoUpdate

suspend fun executeSingleOrNoUpdate(statement: Statement<Int>): Boolean

executeSingleUpdate

suspend fun executeSingleUpdate(statement: Statement<Int>)

executeUpdate

suspend fun executeUpdate(statement: Statement<Int>): Int

executeWithMapping

suspend fun <U> executeWithMapping(statement: Statement<*>, rowMapper: Function<Row, U>): RowSet<U>

exposedReadOnlyTransaction

fun <T> ~~exposedReadOnlyTransaction~~(statement: Transaction.() -> T): T

exposedTransaction

fun <T> ~~exposedTransaction~~(transactionIsolation: Int? = exposedDatabase/*?*/.transactionManager/*?*/.defaultIsolationLevel, readOnly: Boolean? = exposedDatabase/*?*/.transactionManager/*?*/.defaultReadOnly, statement: Transaction.() -> T): T

getConnectionClient

suspend fun DatabaseClient<Pool>.getConnectionClient(): DatabaseClient<SqlConnection>

getFieldExpressionSetWithOptionalReadOnlyExposedTransaction

fun Query.getFieldExpressionSetWithOptionalReadOnlyExposedTransaction(getFieldExpressionSetWithExposedTransaction: Boolean): Set<Expression<*>>

getFieldExpressionSetWithTransaction

fun FieldSet.~~getFieldExpressionSetWithTransaction~~(): Set<Expression<*>>

fun Query.~~getFieldExpressionSetWithTransaction~~(): Set<Expression<*>>

getVertxPoolConnection

suspend fun DatabaseClient<Pool>.getVertxPoolConnection(): SqlConnection

isWorking

suspend fun isWorking(): Boolean

optionalStatementPreparationExposedTransaction

inline fun <T> optionalStatementPreparationExposedTransaction(withExposedTransaction: Boolean, crossinline block: () -> T): T

prepareBatchSqlAndArgTuples

fun prepareBatchSqlAndArgTuples(statements: Iterable<Statement<*>>): Pair<String?, List<Tuple>>

prepareBatchSqlAndArgTuplesWithProvidedTransaction

fun Transaction.prepareBatchSqlAndArgTuplesWithProvidedTransaction(statements: Iterable<Statement<*>>): Pair<String?, List<Tuple>>

prepareSqlAndArgTuple

fun prepareSqlAndArgTuple(statement: Statement<*>): Pair<String, Tuple?>

statementPreparationExposedTransaction

open override fun <T> statementPreparationExposedTransaction(block: Transaction.() -> T): T

Executes the given block within an Exposed transaction context suitable for SQL statement preparation.

withConnectionClient

suspend fun <T> DatabaseClient<Pool>.withConnectionClient(block: suspend (DatabaseClient<SqlConnection>) -> T): T

withExplicitOnlyStatementPreparationExposedTransaction

open override fun <T> ~~withExplicitOnlyStatementPreparationExposedTransaction~~(block: Transaction.() -> T): T

Executes the given block within an Exposed transaction context suitable for SQL statement preparation, without storing the transaction in ThreadLocal or coroutine context.

withSavepoint

suspend fun <SqlConnectionT : SqlConnection, T> DatabaseClient<SqlConnectionT>.withSavepoint(savepointName: String, function: suspend (DatabaseClient<SqlConnectionT>) -> T): T

withSavepointAndRollbackIfThrows

suspend fun <SqlConnectionT : SqlConnection, T> DatabaseClient<SqlConnectionT>.~~withSavepointAndRollbackIfThrows~~(savepointName: String, function: suspend (DatabaseClient<SqlConnectionT>) -> T): T

An alias of withSavepoint.

withSavepointAndRollbackIfThrowsOrFalse

suspend fun <SqlConnectionT : SqlConnection> DatabaseClient<SqlConnectionT>.~~withSavepointAndRollbackIfThrowsOrFalse~~(savepointName: String, function: suspend (DatabaseClient<SqlConnectionT>) -> Boolean): Boolean

withSavepointAndRollbackIfThrowsOrLeft

suspend fun <SqlConnectionT : SqlConnection, RollbackResult, ReleaseResult> DatabaseClient<SqlConnectionT>.~~withSavepointAndRollbackIfThrowsOrLeft~~(savepointName: String, function: suspend (DatabaseClient<SqlConnectionT>) -> Either<RollbackResult, ReleaseResult>): Either<RollbackResult, ReleaseResult>

withSavepointAndRollbackIfThrowsOrNone

suspend fun <SqlConnectionT : SqlConnection, T> DatabaseClient<SqlConnectionT>.~~withSavepointAndRollbackIfThrowsOrNone~~(savepointName: String, function: suspend (DatabaseClient<SqlConnectionT>) -> Option<T>): Option<T>

withSavepointEither

suspend fun <SqlConnectionT : SqlConnection, RollbackResult, ReleaseResult> DatabaseClient<SqlConnectionT>.withSavepointEither(savepointName: String, function: suspend (DatabaseClient<SqlConnectionT>) -> Either<RollbackResult, ReleaseResult>): Either<RollbackResult, ReleaseResult>

Currently only supported with PostgreSQL. A savepoint destroys one with the same name so be careful.

withTransaction

@JvmName(name = "withTransactionForSqlConnection")

suspend fun <SqlConnectionT : SqlConnection, T> DatabaseClient<SqlConnectionT>.withTransaction(function: suspend (DatabaseClient<SqlConnectionT>) -> T): T

@JvmName(name = "withTransactionForPool")

suspend fun <T> DatabaseClient<Pool>.withTransaction(function: suspend (DatabaseClient<SqlConnection>) -> T): T

When using this function, it's recommended to name the lambda parameter the same as the outer receiver so that the outer DatabaseClient is shadowed, and so that you don't call the outer DatabaseClient without a transaction by accident.

withTransactionCommitOrRollback

suspend fun <SqlConnectionT : SqlConnection, T> DatabaseClient<SqlConnectionT>.~~withTransactionCommitOrRollback~~(function: suspend (DatabaseClient<SqlConnectionT>) -> Option<T>): Option<T>

withTransactionEither

@JvmName(name = "withTransactionEitherForSqlConnection")

suspend fun <SqlConnectionT : SqlConnection, RollbackResult, CommitResult> DatabaseClient<SqlConnectionT>.withTransactionEither(function: suspend (DatabaseClient<SqlConnectionT>) -> Either<RollbackResult, CommitResult>): Either<RollbackResult, CommitResult>

@JvmName(name = "withTransactionEitherForPool")

suspend fun <RollbackResult, CommitResult> DatabaseClient<Pool>.withTransactionEither(function: suspend (DatabaseClient<SqlConnection>) -> Either<RollbackResult, CommitResult>): Either<RollbackResult, CommitResult>

withTransactionEitherPolymorphic

suspend fun <RollbackResult, CommitResult> DatabaseClient<*>.withTransactionEitherPolymorphic(function: suspend (DatabaseClient<SqlConnection>) -> Either<RollbackResult, CommitResult>): Either<RollbackResult, CommitResult>

Polymorphic transaction function for DatabaseClient<*> with either Pool or SqlConnection as the DatabaseClient.vertxSqlClient.

withTransactionPolymorphic

suspend fun <T> DatabaseClient<*>.withTransactionPolymorphic(function: suspend (DatabaseClient<SqlConnection>) -> T): T

Polymorphic transaction function for DatabaseClient<*> with either Pool or SqlConnection as the DatabaseClient.vertxSqlClient.

withTypedTransaction

inline suspend fun <SqlConnectionT : SqlConnection, T> DatabaseClient<Pool>.withTypedTransaction(crossinline function: suspend (DatabaseClient<SqlConnectionT>) -> T): T

A variant of withTransaction that casts the SqlConnection to a specific subtype.

withTypedTransactionPolymorphic

inline suspend fun <SqlConnectionT : SqlConnection, T> DatabaseClient<*>.withTypedTransactionPolymorphic(noinline function: suspend (DatabaseClient<SqlConnectionT>) -> T): T

Polymorphic transaction function for DatabaseClient<*> with either Pool or SqlConnection as the DatabaseClient.vertxSqlClient.

withVertxSqlClientCheckedCastTo

inline fun <T : SqlClient> DatabaseClient<*>.withVertxSqlClientCheckedCastTo(): DatabaseClient<T>

withVertxSqlClientCheckedCastToOrNull

inline fun <T : SqlClient> DatabaseClient<*>.withVertxSqlClientCheckedCastToOrNull(): DatabaseClient<T>?

DatabaseClient

Parameters

See also

Constructors

Types

Properties

Functions