Package io.github.zero88.jooqx.mutiny

Class LegacyJooqxTx

java.lang.Object
io.github.zero88.jooqx.mutiny.LegacyJooqxTx
public class LegacyJooqxTx extends Object
Represents for a legacy SQL transaction 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<LegacyJooqxTx> __TYPE_ARG

  • Constructor Details

    • LegacyJooqxTx

      public LegacyJooqxTx(LegacyJooqxTx delegate)

    • LegacyJooqxTx

      public LegacyJooqxTx(Object delegate)

  • Method Details

    • getDelegate

      public LegacyJooqxTx getDelegate()

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • equals

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

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • 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.

      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).

      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.

      Parameters:
      statement - the plain SQL statement without result

    • session

      public LegacyJooqxSession session()

    • transaction

      public LegacyJooqxTx transaction()

    • run

      @CheckReturnValue public <X> io.smallrye.mutiny.Uni<X> run(Function<LegacyJooqxTx,io.smallrye.mutiny.Uni<X>> transactionFn)

    • runAndAwait

      public <X> X runAndAwait(Function<LegacyJooqxTx,io.smallrye.mutiny.Uni<X>> transactionFn)

    • runAndForget

      public <X> void runAndForget(Function<LegacyJooqxTx,io.smallrye.mutiny.Uni<X>> transactionFn)

    • 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.

      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).

      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.

      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.

      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).

      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.

      Parameters:
      blockQuery - the block of SQL queries

    • 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.

      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).

      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.

      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.

      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).

      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.

      Parameters:
      statement - DDL statement

    • 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.

      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).

      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.

      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.

      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).

      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.

      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.

      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).

      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.

      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.

      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).

      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.

      Parameters:
      statement - a row count query statement

    • 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.

      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).

      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.

      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.

      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).

      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.

      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.

      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).

      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.

      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.

      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).

      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.

      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.

      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).

      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.

      Parameters:
      query - query
      bindBatchValues - bind batch values

    • routine

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

    • routineAndAwait

      public <T> T routineAndAwait(Function<org.jooq.DSLContext,org.jooq.Routine<T>> routineFunction)

    • routineAndForget

      public <T> void routineAndForget(Function<org.jooq.DSLContext,org.jooq.Routine<T>> routineFunction)

    • routine

      @CheckReturnValue public <T> io.smallrye.mutiny.Uni<T> routine(org.jooq.Routine<T> routine)

    • routineAndAwait

      public <T> T routineAndAwait(org.jooq.Routine<T> routine)

    • routineAndForget

      public <T> void routineAndForget(org.jooq.Routine<T> routine)

    • routineResult

      @CheckReturnValue public <T> io.smallrye.mutiny.Uni<RoutineResult> routineResult(org.jooq.Routine<T> routine)

    • routineResultAndAwait

      public <T> RoutineResult routineResultAndAwait(org.jooq.Routine<T> routine)

    • routineResultAndForget

      public <T> void routineResultAndForget(org.jooq.Routine<T> routine)

    • routineResultSet

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

    • routineResultSetAndAwait

      public <T, X, R> R routineResultSetAndAwait(org.jooq.Routine<T> routine, SQLResultAdapter<X,R> resultAdapter)

    • routineResultSetAndForget

      public <T, X, R> void routineResultSetAndForget(org.jooq.Routine<T> routine, SQLResultAdapter<X,R> resultAdapter)

    • newInstance

      public static LegacyJooqxTx newInstance(LegacyJooqxTx arg)