Package io.github.zero88.jooqx.mutiny

Class JooqxSession

java.lang.Object
io.github.zero88.jooqx.mutiny.JooqxConn
io.github.zero88.jooqx.mutiny.JooqxSession
public class JooqxSession extends JooqxConn
Represents for a reactive SQL session executor

NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.

  • Field Details

    • __TYPE_ARG

      public static final io.smallrye.mutiny.vertx.TypeArg<JooqxSession> __TYPE_ARG

  • Constructor Details

    • JooqxSession

      public JooqxSession(JooqxSession delegate)

    • JooqxSession

      public JooqxSession(Object delegate)

  • Method Details

    • getDelegate

      public JooqxSession getDelegate()
      Overrides:
      getDelegate in class JooqxConn

    • toString

      public String toString()
      Overrides:
      toString in class JooqxConn

    • equals

      public boolean equals(Object o)
      Overrides:
      equals in class JooqxConn

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class JooqxConn

    • sql

      @CheckReturnValue public io.smallrye.mutiny.Uni<Integer> sql(String statement)
      Execute the plain SQL statement without result (e.g: SET, INSERT, UPDATE, etc...)

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Overrides:
      sql in class JooqxConn
      Parameters:
      statement - the plain SQL statement without result
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • sqlAndAwait

      public Integer sqlAndAwait(String statement)
      Blocking variant of SQLPlainExecutor.sql(String).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Overrides:
      sqlAndAwait in class JooqxConn
      Parameters:
      statement - the plain SQL statement without result
      Returns:
      the Integer instance produced by the operation.

    • sqlAndForget

      public void sqlAndForget(String statement)
      Variant of SQLPlainExecutor.sql(String) that ignores the result of the operation.

      This method subscribes on the result of SQLPlainExecutor.sql(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from SQLPlainExecutor.sql(String) but you don't need to compose it with other operations.

      Overrides:
      sqlAndForget in class JooqxConn
      Parameters:
      statement - the plain SQL statement without result

    • session

      public JooqxSession session()
      Overrides:
      session in class JooqxConn

    • perform

      @CheckReturnValue public <R> io.smallrye.mutiny.Uni<R> perform(Function<JooqxSession,io.smallrye.mutiny.Uni<R>> sessionFn)

    • performAndAwait

      public <R> R performAndAwait(Function<JooqxSession,io.smallrye.mutiny.Uni<R>> sessionFn)

    • performAndForget

      public <R> void performAndForget(Function<JooqxSession,io.smallrye.mutiny.Uni<R>> sessionFn)

    • batchResult

      @CheckReturnValue public <T, R> io.smallrye.mutiny.Uni<BatchReturningResult<R>> batchResult(Function<org.jooq.DSLContext,org.jooq.Query> queryFunction, BindBatchValues bindBatchValues, SQLResultListAdapter<T,R> adapter)
      Result batch execute

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Overrides:
      batchResult in class JooqxConn
      Parameters:
      queryFunction - query function
      bindBatchValues - bind batch values
      adapter -
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • batchResultAndAwait

      public <T, R> BatchReturningResult<R> batchResultAndAwait(Function<org.jooq.DSLContext,org.jooq.Query> queryFunction, BindBatchValues bindBatchValues, SQLResultListAdapter<T,R> adapter)
      Blocking variant of SQLBatchResultExecutor.batchResult(Function,BindBatchValues,SQLResultListAdapter).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Overrides:
      batchResultAndAwait in class JooqxConn
      Parameters:
      queryFunction - query function
      bindBatchValues - bind batch values
      adapter -
      Returns:
      the BatchReturningResult instance produced by the operation.

    • batchResultAndForget

      public <T, R> void batchResultAndForget(Function<org.jooq.DSLContext,org.jooq.Query> queryFunction, BindBatchValues bindBatchValues, SQLResultListAdapter<T,R> adapter)
      Variant of SQLBatchResultExecutor.batchResult(Function,BindBatchValues,SQLResultListAdapter) that ignores the result of the operation.

      This method subscribes on the result of SQLBatchResultExecutor.batchResult(Function,BindBatchValues,SQLResultListAdapter), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from SQLBatchResultExecutor.batchResult(Function,BindBatchValues,SQLResultListAdapter) but you don't need to compose it with other operations.

      Overrides:
      batchResultAndForget in class JooqxConn
      Parameters:
      queryFunction - query function
      bindBatchValues - bind batch values
      adapter -

    • batchResult

      @CheckReturnValue public <T, R> io.smallrye.mutiny.Uni<BatchReturningResult<R>> batchResult(org.jooq.Query query, BindBatchValues bindBatchValues, SQLResultListAdapter<T,R> adapter)
      Execute batch statements then receive results

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Overrides:
      batchResult in class JooqxConn
      Parameters:
      query - jOOQ query
      bindBatchValues - bind batch values
      adapter - result adapter
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • batchResultAndAwait

      public <T, R> BatchReturningResult<R> batchResultAndAwait(org.jooq.Query query, BindBatchValues bindBatchValues, SQLResultListAdapter<T,R> adapter)
      Blocking variant of SQLBatchResultExecutor.batchResult(Query,BindBatchValues,SQLResultListAdapter).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Overrides:
      batchResultAndAwait in class JooqxConn
      Parameters:
      query - jOOQ query
      bindBatchValues - bind batch values
      adapter - result adapter
      Returns:
      the BatchReturningResult instance produced by the operation.

    • batchResultAndForget

      public <T, R> void batchResultAndForget(org.jooq.Query query, BindBatchValues bindBatchValues, SQLResultListAdapter<T,R> adapter)
      Variant of SQLBatchResultExecutor.batchResult(Query,BindBatchValues,SQLResultListAdapter) that ignores the result of the operation.

      This method subscribes on the result of SQLBatchResultExecutor.batchResult(Query,BindBatchValues,SQLResultListAdapter), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from SQLBatchResultExecutor.batchResult(Query,BindBatchValues,SQLResultListAdapter) but you don't need to compose it with other operations.

      Overrides:
      batchResultAndForget in class JooqxConn
      Parameters:
      query - jOOQ query
      bindBatchValues - bind batch values
      adapter - result adapter

    • routine

      @CheckReturnValue public <T> io.smallrye.mutiny.Uni<T> routine(Function<org.jooq.DSLContext,org.jooq.Routine<T>> routineFunction)
      Overrides:
      routine in class JooqxConn

    • routineAndAwait

      public <T> T routineAndAwait(Function<org.jooq.DSLContext,org.jooq.Routine<T>> routineFunction)
      Overrides:
      routineAndAwait in class JooqxConn

    • routineAndForget

      public <T> void routineAndForget(Function<org.jooq.DSLContext,org.jooq.Routine<T>> routineFunction)
      Overrides:
      routineAndForget in class JooqxConn

    • routine

      @CheckReturnValue public <T> io.smallrye.mutiny.Uni<T> routine(org.jooq.Routine<T> routine)
      Overrides:
      routine in class JooqxConn

    • routineAndAwait

      public <T> T routineAndAwait(org.jooq.Routine<T> routine)
      Overrides:
      routineAndAwait in class JooqxConn

    • routineAndForget

      public <T> void routineAndForget(org.jooq.Routine<T> routine)
      Overrides:
      routineAndForget in class JooqxConn

    • routineResult

      @CheckReturnValue public <T> io.smallrye.mutiny.Uni<RoutineResult> routineResult(org.jooq.Routine<T> routine)
      Overrides:
      routineResult in class JooqxConn

    • routineResultAndAwait

      public <T> RoutineResult routineResultAndAwait(org.jooq.Routine<T> routine)
      Overrides:
      routineResultAndAwait in class JooqxConn

    • routineResultAndForget

      public <T> void routineResultAndForget(org.jooq.Routine<T> routine)
      Overrides:
      routineResultAndForget in class JooqxConn

    • routineResultSet

      @CheckReturnValue public <T, X, R> io.smallrye.mutiny.Uni<R> routineResultSet(org.jooq.Routine<T> routine, SQLResultAdapter<X,R> resultAdapter)
      Overrides:
      routineResultSet in class JooqxConn

    • routineResultSetAndAwait

      public <T, X, R> R routineResultSetAndAwait(org.jooq.Routine<T> routine, SQLResultAdapter<X,R> resultAdapter)
      Overrides:
      routineResultSetAndAwait in class JooqxConn

    • routineResultSetAndForget

      public <T, X, R> void routineResultSetAndForget(org.jooq.Routine<T> routine, SQLResultAdapter<X,R> resultAdapter)
      Overrides:
      routineResultSetAndForget in class JooqxConn

    • block

      @CheckReturnValue public io.smallrye.mutiny.Uni<BlockResult> block(Function<org.jooq.DSLContext,BlockQuery> blockQueryFn)
      Block execute

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Overrides:
      block in class JooqxConn
      Parameters:
      blockQueryFn - the block of SQL queries function
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • blockAndAwait

      public BlockResult blockAndAwait(Function<org.jooq.DSLContext,BlockQuery> blockQueryFn)
      Blocking variant of SQLBlockExecutor.block(Function).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Overrides:
      blockAndAwait in class JooqxConn
      Parameters:
      blockQueryFn - the block of SQL queries function
      Returns:
      the BlockResult instance produced by the operation.

    • blockAndForget

      public void blockAndForget(Function<org.jooq.DSLContext,BlockQuery> blockQueryFn)
      Variant of SQLBlockExecutor.block(Function) that ignores the result of the operation.

      This method subscribes on the result of SQLBlockExecutor.block(Function), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from SQLBlockExecutor.block(Function) but you don't need to compose it with other operations.

      Overrides:
      blockAndForget in class JooqxConn
      Parameters:
      blockQueryFn - the block of SQL queries function

    • block

      @CheckReturnValue public io.smallrye.mutiny.Uni<BlockResult> block(BlockQuery blockQuery)
      Block execute

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Overrides:
      block in class JooqxConn
      Parameters:
      blockQuery - the block of SQL queries
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • blockAndAwait

      public BlockResult blockAndAwait(BlockQuery blockQuery)
      Blocking variant of SQLBlockExecutor.block(BlockQuery).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Overrides:
      blockAndAwait in class JooqxConn
      Parameters:
      blockQuery - the block of SQL queries
      Returns:
      the BlockResult instance produced by the operation.

    • blockAndForget

      public void blockAndForget(BlockQuery blockQuery)
      Variant of SQLBlockExecutor.block(BlockQuery) that ignores the result of the operation.

      This method subscribes on the result of SQLBlockExecutor.block(BlockQuery), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from SQLBlockExecutor.block(BlockQuery) but you don't need to compose it with other operations.

      Overrides:
      blockAndForget in class JooqxConn
      Parameters:
      blockQuery - the block of SQL queries

    • sql

      @CheckReturnValue public io.smallrye.mutiny.Uni<Integer> sql(Function<org.jooq.DSLContext,String> sqlFunction)
      Execute the plain SQL statement without result (e.g: SET, INSERT, UPDATE, etc...)

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Overrides:
      sql in class JooqxConn
      Parameters:
      sqlFunction - the plain SQL function products a plain SQL statement without result
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • sqlAndAwait

      public Integer sqlAndAwait(Function<org.jooq.DSLContext,String> sqlFunction)
      Blocking variant of SQLPlainExecutor.sql(Function).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Overrides:
      sqlAndAwait in class JooqxConn
      Parameters:
      sqlFunction - the plain SQL function products a plain SQL statement without result
      Returns:
      the Integer instance produced by the operation.

    • sqlAndForget

      public void sqlAndForget(Function<org.jooq.DSLContext,String> sqlFunction)
      Variant of SQLPlainExecutor.sql(Function) that ignores the result of the operation.

      This method subscribes on the result of SQLPlainExecutor.sql(Function), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from SQLPlainExecutor.sql(Function) but you don't need to compose it with other operations.

      Overrides:
      sqlAndForget in class JooqxConn
      Parameters:
      sqlFunction - the plain SQL function products a plain SQL statement without result

    • sqlQuery

      @CheckReturnValue public <T, R> io.smallrye.mutiny.Uni<R> sqlQuery(Function<org.jooq.DSLContext,String> sqlFunction, SQLResultAdapter<T,R> adapter)
      Execute the plain SQL statement with results (e.g: SELECT, etc...)

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Overrides:
      sqlQuery in class JooqxConn
      Parameters:
      sqlFunction - the plain SQL function products a plain SQL statement with results
      adapter - the result adapter
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • sqlQueryAndAwait

      public <T, R> R sqlQueryAndAwait(Function<org.jooq.DSLContext,String> sqlFunction, SQLResultAdapter<T,R> adapter)
      Blocking variant of SQLPlainExecutor.sqlQuery(Function,SQLResultAdapter).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Overrides:
      sqlQueryAndAwait in class JooqxConn
      Parameters:
      sqlFunction - the plain SQL function products a plain SQL statement with results
      adapter - the result adapter
      Returns:
      the R instance produced by the operation.

    • sqlQueryAndForget

      public <T, R> void sqlQueryAndForget(Function<org.jooq.DSLContext,String> sqlFunction, SQLResultAdapter<T,R> adapter)
      Variant of SQLPlainExecutor.sqlQuery(Function,SQLResultAdapter) that ignores the result of the operation.

      This method subscribes on the result of SQLPlainExecutor.sqlQuery(Function,SQLResultAdapter), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from SQLPlainExecutor.sqlQuery(Function,SQLResultAdapter) but you don't need to compose it with other operations.

      Overrides:
      sqlQueryAndForget in class JooqxConn
      Parameters:
      sqlFunction - the plain SQL function products a plain SQL statement with results
      adapter - the result adapter

    • sqlQuery

      @CheckReturnValue public <T, R> io.smallrye.mutiny.Uni<R> sqlQuery(String statement, SQLResultAdapter<T,R> adapter)
      Execute the plain SQL statement with results (e.g: SELECT, etc...)

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Overrides:
      sqlQuery in class JooqxConn
      Parameters:
      statement - the plain SQL statement with results
      adapter - the result adapter
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • sqlQueryAndAwait

      public <T, R> R sqlQueryAndAwait(String statement, SQLResultAdapter<T,R> adapter)
      Blocking variant of SQLPlainExecutor.sqlQuery(String,SQLResultAdapter).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Overrides:
      sqlQueryAndAwait in class JooqxConn
      Parameters:
      statement - the plain SQL statement with results
      adapter - the result adapter
      Returns:
      the R instance produced by the operation.

    • sqlQueryAndForget

      public <T, R> void sqlQueryAndForget(String statement, SQLResultAdapter<T,R> adapter)
      Variant of SQLPlainExecutor.sqlQuery(String,SQLResultAdapter) that ignores the result of the operation.

      This method subscribes on the result of SQLPlainExecutor.sqlQuery(String,SQLResultAdapter), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from SQLPlainExecutor.sqlQuery(String,SQLResultAdapter) but you don't need to compose it with other operations.

      Overrides:
      sqlQueryAndForget in class JooqxConn
      Parameters:
      statement - the plain SQL statement with results
      adapter - the result adapter

    • batch

      @CheckReturnValue public io.smallrye.mutiny.Uni<BatchResult> batch(Function<org.jooq.DSLContext,org.jooq.Query> queryFunction, BindBatchValues bindBatchValues)
      Batch execute

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Overrides:
      batch in class JooqxConn
      Parameters:
      queryFunction - query function
      bindBatchValues - bind batch values
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • batchAndAwait

      public BatchResult batchAndAwait(Function<org.jooq.DSLContext,org.jooq.Query> queryFunction, BindBatchValues bindBatchValues)
      Blocking variant of SQLBatchExecutor.batch(Function,BindBatchValues).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Overrides:
      batchAndAwait in class JooqxConn
      Parameters:
      queryFunction - query function
      bindBatchValues - bind batch values
      Returns:
      the BatchResult instance produced by the operation.

    • batchAndForget

      public void batchAndForget(Function<org.jooq.DSLContext,org.jooq.Query> queryFunction, BindBatchValues bindBatchValues)
      Variant of SQLBatchExecutor.batch(Function,BindBatchValues) that ignores the result of the operation.

      This method subscribes on the result of SQLBatchExecutor.batch(Function,BindBatchValues), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from SQLBatchExecutor.batch(Function,BindBatchValues) but you don't need to compose it with other operations.

      Overrides:
      batchAndForget in class JooqxConn
      Parameters:
      queryFunction - query function
      bindBatchValues - bind batch values

    • batch

      @CheckReturnValue public io.smallrye.mutiny.Uni<BatchResult> batch(org.jooq.Query query, BindBatchValues bindBatchValues)
      Batch execute

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Overrides:
      batch in class JooqxConn
      Parameters:
      query - query
      bindBatchValues - bind batch values
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • batchAndAwait

      public BatchResult batchAndAwait(org.jooq.Query query, BindBatchValues bindBatchValues)
      Blocking variant of SQLBatchExecutor.batch(Query,BindBatchValues).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Overrides:
      batchAndAwait in class JooqxConn
      Parameters:
      query - query
      bindBatchValues - bind batch values
      Returns:
      the BatchResult instance produced by the operation.

    • batchAndForget

      public void batchAndForget(org.jooq.Query query, BindBatchValues bindBatchValues)
      Variant of SQLBatchExecutor.batch(Query,BindBatchValues) that ignores the result of the operation.

      This method subscribes on the result of SQLBatchExecutor.batch(Query,BindBatchValues), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from SQLBatchExecutor.batch(Query,BindBatchValues) but you don't need to compose it with other operations.

      Overrides:
      batchAndForget in class JooqxConn
      Parameters:
      query - query
      bindBatchValues - bind batch values

    • execute

      @CheckReturnValue public <T, R> io.smallrye.mutiny.Uni<R> execute(Function<org.jooq.DSLContext,org.jooq.Query> queryFunction, SQLResultAdapter<T,R> resultAdapter)
      Execute jOOQ query then return async result

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Overrides:
      execute in class JooqxConn
      Parameters:
      queryFunction - the jOOQ query function
      resultAdapter - the result adapter
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • executeAndAwait

      public <T, R> R executeAndAwait(Function<org.jooq.DSLContext,org.jooq.Query> queryFunction, SQLResultAdapter<T,R> resultAdapter)
      Blocking variant of SQLStatementExecutor.execute(Function,SQLResultAdapter).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Overrides:
      executeAndAwait in class JooqxConn
      Parameters:
      queryFunction - the jOOQ query function
      resultAdapter - the result adapter
      Returns:
      the R instance produced by the operation.

    • executeAndForget

      public <T, R> void executeAndForget(Function<org.jooq.DSLContext,org.jooq.Query> queryFunction, SQLResultAdapter<T,R> resultAdapter)
      Variant of SQLStatementExecutor.execute(Function,SQLResultAdapter) that ignores the result of the operation.

      This method subscribes on the result of SQLStatementExecutor.execute(Function,SQLResultAdapter), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from SQLStatementExecutor.execute(Function,SQLResultAdapter) but you don't need to compose it with other operations.

      Overrides:
      executeAndForget in class JooqxConn
      Parameters:
      queryFunction - the jOOQ query function
      resultAdapter - the result adapter

    • execute

      @CheckReturnValue public <T, R> io.smallrye.mutiny.Uni<R> execute(org.jooq.Query query, SQLResultAdapter<T,R> resultAdapter)
      Execute jOOQ query then return async result

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Overrides:
      execute in class JooqxConn
      Parameters:
      query - the jOOQ query
      resultAdapter - the result adapter
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • executeAndAwait

      public <T, R> R executeAndAwait(org.jooq.Query query, SQLResultAdapter<T,R> resultAdapter)
      Blocking variant of SQLStatementExecutor.execute(Query,SQLResultAdapter).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Overrides:
      executeAndAwait in class JooqxConn
      Parameters:
      query - the jOOQ query
      resultAdapter - the result adapter
      Returns:
      the R instance produced by the operation.

    • executeAndForget

      public <T, R> void executeAndForget(org.jooq.Query query, SQLResultAdapter<T,R> resultAdapter)
      Variant of SQLStatementExecutor.execute(Query,SQLResultAdapter) that ignores the result of the operation.

      This method subscribes on the result of SQLStatementExecutor.execute(Query,SQLResultAdapter), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from SQLStatementExecutor.execute(Query,SQLResultAdapter) but you don't need to compose it with other operations.

      Overrides:
      executeAndForget in class JooqxConn
      Parameters:
      query - the jOOQ query
      resultAdapter - the result adapter

    • execute

      @CheckReturnValue public io.smallrye.mutiny.Uni<Integer> execute(Function<org.jooq.DSLContext,org.jooq.RowCountQuery> rowCountQueryFn)
      Execute row count query statement

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Overrides:
      execute in class JooqxConn
      Parameters:
      rowCountQueryFn - A function produces row count query statement
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • executeAndAwait

      public Integer executeAndAwait(Function<org.jooq.DSLContext,org.jooq.RowCountQuery> rowCountQueryFn)
      Blocking variant of SQLStatementExecutor.execute(Function).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Overrides:
      executeAndAwait in class JooqxConn
      Parameters:
      rowCountQueryFn - A function produces row count query statement
      Returns:
      the Integer instance produced by the operation.

    • executeAndForget

      public void executeAndForget(Function<org.jooq.DSLContext,org.jooq.RowCountQuery> rowCountQueryFn)
      Variant of SQLStatementExecutor.execute(Function) that ignores the result of the operation.

      This method subscribes on the result of SQLStatementExecutor.execute(Function), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from SQLStatementExecutor.execute(Function) but you don't need to compose it with other operations.

      Overrides:
      executeAndForget in class JooqxConn
      Parameters:
      rowCountQueryFn - A function produces row count query statement

    • execute

      @CheckReturnValue public io.smallrye.mutiny.Uni<Integer> execute(org.jooq.RowCountQuery statement)
      Execute row count query statement

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Overrides:
      execute in class JooqxConn
      Parameters:
      statement - a row count query statement
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • executeAndAwait

      public Integer executeAndAwait(org.jooq.RowCountQuery statement)
      Blocking variant of SQLStatementExecutor.execute(RowCountQuery).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Overrides:
      executeAndAwait in class JooqxConn
      Parameters:
      statement - a row count query statement
      Returns:
      the Integer instance produced by the operation.

    • executeAndForget

      public void executeAndForget(org.jooq.RowCountQuery statement)
      Variant of SQLStatementExecutor.execute(RowCountQuery) that ignores the result of the operation.

      This method subscribes on the result of SQLStatementExecutor.execute(RowCountQuery), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from SQLStatementExecutor.execute(RowCountQuery) but you don't need to compose it with other operations.

      Overrides:
      executeAndForget in class JooqxConn
      Parameters:
      statement - a row count query statement

    • ddl

      @CheckReturnValue public io.smallrye.mutiny.Uni<Integer> ddl(Function<org.jooq.DSLContext,org.jooq.DDLQuery> ddlFunction)
      Execute DDL statement

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Overrides:
      ddl in class JooqxConn
      Parameters:
      ddlFunction - DDL function produces DDL statement
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • ddlAndAwait

      public Integer ddlAndAwait(Function<org.jooq.DSLContext,org.jooq.DDLQuery> ddlFunction)
      Blocking variant of SQLDDLExecutor.ddl(Function).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Overrides:
      ddlAndAwait in class JooqxConn
      Parameters:
      ddlFunction - DDL function produces DDL statement
      Returns:
      the Integer instance produced by the operation.

    • ddlAndForget

      public void ddlAndForget(Function<org.jooq.DSLContext,org.jooq.DDLQuery> ddlFunction)
      Variant of SQLDDLExecutor.ddl(Function) that ignores the result of the operation.

      This method subscribes on the result of SQLDDLExecutor.ddl(Function), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from SQLDDLExecutor.ddl(Function) but you don't need to compose it with other operations.

      Overrides:
      ddlAndForget in class JooqxConn
      Parameters:
      ddlFunction - DDL function produces DDL statement

    • ddl

      @CheckReturnValue public io.smallrye.mutiny.Uni<Integer> ddl(org.jooq.DDLQuery statement)
      Execute DDL statement

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Overrides:
      ddl in class JooqxConn
      Parameters:
      statement - DDL statement
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • ddlAndAwait

      public Integer ddlAndAwait(org.jooq.DDLQuery statement)
      Blocking variant of SQLDDLExecutor.ddl(DDLQuery).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Overrides:
      ddlAndAwait in class JooqxConn
      Parameters:
      statement - DDL statement
      Returns:
      the Integer instance produced by the operation.

    • ddlAndForget

      public void ddlAndForget(org.jooq.DDLQuery statement)
      Variant of SQLDDLExecutor.ddl(DDLQuery) that ignores the result of the operation.

      This method subscribes on the result of SQLDDLExecutor.ddl(DDLQuery), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from SQLDDLExecutor.ddl(DDLQuery) but you don't need to compose it with other operations.

      Overrides:
      ddlAndForget in class JooqxConn
      Parameters:
      statement - DDL statement

    • newInstance

      public static JooqxSession newInstance(JooqxSession arg)