Class Jooqx

java.lang.Object
io.github.zero88.jooqx.reactivex.Jooqx

public class Jooqx extends Object
Represents for an executor that executes jOOQ query on Vertx reactive SQL pool

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

  • Field Details

    • __TYPE_ARG

      public static final io.vertx.lang.rx.TypeArg<Jooqx> __TYPE_ARG
  • Constructor Details

    • Jooqx

      public Jooqx(Jooqx delegate)
    • Jooqx

      public Jooqx(Object delegate)
  • Method Details

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

      public Jooqx getDelegate()
    • sql

      public void sql(String statement, io.vertx.core.Handler<io.vertx.core.AsyncResult<Integer>> handler)
      Execute the plain SQL statement without result (e.g: SET, INSERT, UPDATE, etc...)
      Parameters:
      statement - the plain SQL statement without result
      handler - async result handler
    • sql

      public void sql(String statement)
      Execute the plain SQL statement without result (e.g: SET, INSERT, UPDATE, etc...)
      Parameters:
      statement - the plain SQL statement without result
    • rxSql

      public io.reactivex.Single<Integer> rxSql(String statement)
      Execute the plain SQL statement without result (e.g: SET, INSERT, UPDATE, etc...)
      Parameters:
      statement - the plain SQL statement without result
      Returns:
    • builder

      public static JooqxBuilder builder()
      Create a builder
      Returns:
      jooqx builder
    • vertx

      public io.vertx.reactivex.core.Vertx vertx()
    • sqlClient

      public io.vertx.reactivex.sqlclient.Pool sqlClient()
      Returns:
    • preparedQuery

      public JooqxPreparedQuery preparedQuery()
      Returns:
    • resultCollector

      public JooqxResultCollector resultCollector()
      Returns:
    • transaction

      public JooqxTx transaction()
      Returns:
    • session

      public JooqxSession session()
      Returns:
    • block

      public void block(Function<org.jooq.DSLContext,BlockQuery> blockQueryFn, io.vertx.core.Handler<io.vertx.core.AsyncResult<BlockResult>> handler)
      Block execute
      Parameters:
      blockQueryFn - the block of SQL queries function
      handler - the async result handler
    • block

      public void block(Function<org.jooq.DSLContext,BlockQuery> blockQueryFn)
      Block execute
      Parameters:
      blockQueryFn - the block of SQL queries function
    • rxBlock

      public io.reactivex.Single<BlockResult> rxBlock(Function<org.jooq.DSLContext,BlockQuery> blockQueryFn)
      Block execute
      Parameters:
      blockQueryFn - the block of SQL queries function
      Returns:
    • block

      public void block(BlockQuery blockQuery, io.vertx.core.Handler<io.vertx.core.AsyncResult<BlockResult>> handler)
      Block execute
      Parameters:
      blockQuery - the block of SQL queries
      handler - the async result handler
    • block

      public void block(BlockQuery blockQuery)
      Block execute
      Parameters:
      blockQuery - the block of SQL queries
    • rxBlock

      public io.reactivex.Single<BlockResult> rxBlock(BlockQuery blockQuery)
      Block execute
      Parameters:
      blockQuery - the block of SQL queries
      Returns:
    • ddl

      public void ddl(Function<org.jooq.DSLContext,org.jooq.DDLQuery> ddlFunction, io.vertx.core.Handler<io.vertx.core.AsyncResult<Integer>> handler)
      Execute DDL statement
      Parameters:
      ddlFunction - DDL function produces DDL statement
      handler - async result handler
    • ddl

      public void ddl(Function<org.jooq.DSLContext,org.jooq.DDLQuery> ddlFunction)
      Execute DDL statement
      Parameters:
      ddlFunction - DDL function produces DDL statement
    • rxDdl

      public io.reactivex.Single<Integer> rxDdl(Function<org.jooq.DSLContext,org.jooq.DDLQuery> ddlFunction)
      Execute DDL statement
      Parameters:
      ddlFunction - DDL function produces DDL statement
      Returns:
    • ddl

      public void ddl(org.jooq.DDLQuery statement, io.vertx.core.Handler<io.vertx.core.AsyncResult<Integer>> handler)
      Execute DDL statement
      Parameters:
      statement - DDL statement
      handler - async result handler
    • ddl

      public void ddl(org.jooq.DDLQuery statement)
      Execute DDL statement
      Parameters:
      statement - DDL statement
    • rxDdl

      public io.reactivex.Single<Integer> rxDdl(org.jooq.DDLQuery statement)
      Execute DDL statement
      Parameters:
      statement - DDL statement
      Returns:
    • execute

      public <T, R> void execute(Function<org.jooq.DSLContext,org.jooq.Query> queryFunction, SQLResultAdapter<T,R> resultAdapter, io.vertx.core.Handler<io.vertx.core.AsyncResult<R>> handler)
      Execute jOOQ query then return async result
      Parameters:
      queryFunction - the jOOQ query function
      resultAdapter - the result adapter
      handler - the async result handler
    • execute

      public <T, R> void execute(Function<org.jooq.DSLContext,org.jooq.Query> queryFunction, SQLResultAdapter<T,R> resultAdapter)
      Execute jOOQ query then return async result
      Parameters:
      queryFunction - the jOOQ query function
      resultAdapter - the result adapter
    • rxExecute

      public <T, R> io.reactivex.Maybe<R> rxExecute(Function<org.jooq.DSLContext,org.jooq.Query> queryFunction, SQLResultAdapter<T,R> resultAdapter)
      Execute jOOQ query then return async result
      Parameters:
      queryFunction - the jOOQ query function
      resultAdapter - the result adapter
      Returns:
    • execute

      public <T, R> void execute(org.jooq.Query query, SQLResultAdapter<T,R> resultAdapter, io.vertx.core.Handler<io.vertx.core.AsyncResult<R>> handler)
      Execute jOOQ query then return async result
      Parameters:
      query - the jOOQ query
      resultAdapter - the result adapter
      handler - the async result handler
    • execute

      public <T, R> void execute(org.jooq.Query query, SQLResultAdapter<T,R> resultAdapter)
      Execute jOOQ query then return async result
      Parameters:
      query - the jOOQ query
      resultAdapter - the result adapter
    • rxExecute

      public <T, R> io.reactivex.Maybe<R> rxExecute(org.jooq.Query query, SQLResultAdapter<T,R> resultAdapter)
      Execute jOOQ query then return async result
      Parameters:
      query - the jOOQ query
      resultAdapter - the result adapter
      Returns:
    • execute

      public void execute(Function<org.jooq.DSLContext,org.jooq.RowCountQuery> rowCountQueryFn, io.vertx.core.Handler<io.vertx.core.AsyncResult<Integer>> handler)
      Execute row count query statement
      Parameters:
      rowCountQueryFn - A function produces row count query statement
      handler - async result handler
    • execute

      public void execute(Function<org.jooq.DSLContext,org.jooq.RowCountQuery> rowCountQueryFn)
      Execute row count query statement
      Parameters:
      rowCountQueryFn - A function produces row count query statement
    • rxExecute

      public io.reactivex.Single<Integer> rxExecute(Function<org.jooq.DSLContext,org.jooq.RowCountQuery> rowCountQueryFn)
      Execute row count query statement
      Parameters:
      rowCountQueryFn - A function produces row count query statement
      Returns:
    • execute

      public void execute(org.jooq.RowCountQuery statement, io.vertx.core.Handler<io.vertx.core.AsyncResult<Integer>> handler)
      Execute row count query statement
      Parameters:
      statement - a row count query statement
      handler - async result handler
    • execute

      public void execute(org.jooq.RowCountQuery statement)
      Execute row count query statement
      Parameters:
      statement - a row count query statement
    • rxExecute

      public io.reactivex.Single<Integer> rxExecute(org.jooq.RowCountQuery statement)
      Execute row count query statement
      Parameters:
      statement - a row count query statement
      Returns:
    • sql

      public void sql(Function<org.jooq.DSLContext,String> sqlFunction, io.vertx.core.Handler<io.vertx.core.AsyncResult<Integer>> handler)
      Execute the plain SQL statement without result (e.g: SET, INSERT, UPDATE, etc...)
      Parameters:
      sqlFunction - the plain SQL function products a plain SQL statement without result
      handler - async result handler
    • sql

      public void sql(Function<org.jooq.DSLContext,String> sqlFunction)
      Execute the plain SQL statement without result (e.g: SET, INSERT, UPDATE, etc...)
      Parameters:
      sqlFunction - the plain SQL function products a plain SQL statement without result
    • rxSql

      public io.reactivex.Single<Integer> rxSql(Function<org.jooq.DSLContext,String> sqlFunction)
      Execute the plain SQL statement without result (e.g: SET, INSERT, UPDATE, etc...)
      Parameters:
      sqlFunction - the plain SQL function products a plain SQL statement without result
      Returns:
    • sqlQuery

      public <T, R> void sqlQuery(Function<org.jooq.DSLContext,String> sqlFunction, SQLResultAdapter<T,R> adapter, io.vertx.core.Handler<io.vertx.core.AsyncResult<R>> handler)
      Execute the plain SQL statement with results (e.g: SELECT, etc...)
      Parameters:
      sqlFunction - the plain SQL function products a plain SQL statement with results
      adapter - the result adapter
      handler - async result handler
    • sqlQuery

      public <T, R> void sqlQuery(Function<org.jooq.DSLContext,String> sqlFunction, SQLResultAdapter<T,R> adapter)
      Execute the plain SQL statement with results (e.g: SELECT, etc...)
      Parameters:
      sqlFunction - the plain SQL function products a plain SQL statement with results
      adapter - the result adapter
    • rxSqlQuery

      public <T, R> io.reactivex.Maybe<R> rxSqlQuery(Function<org.jooq.DSLContext,String> sqlFunction, SQLResultAdapter<T,R> adapter)
      Execute the plain SQL statement with results (e.g: SELECT, etc...)
      Parameters:
      sqlFunction - the plain SQL function products a plain SQL statement with results
      adapter - the result adapter
      Returns:
    • sqlQuery

      public <T, R> void sqlQuery(String statement, SQLResultAdapter<T,R> adapter, io.vertx.core.Handler<io.vertx.core.AsyncResult<R>> handler)
      Execute the plain SQL statement with results (e.g: SELECT, etc...)
      Parameters:
      statement - the plain SQL statement with results
      adapter - the result adapter
      handler - async result handler
    • sqlQuery

      public <T, R> void sqlQuery(String statement, SQLResultAdapter<T,R> adapter)
      Execute the plain SQL statement with results (e.g: SELECT, etc...)
      Parameters:
      statement - the plain SQL statement with results
      adapter - the result adapter
    • rxSqlQuery

      public <T, R> io.reactivex.Maybe<R> rxSqlQuery(String statement, SQLResultAdapter<T,R> adapter)
      Execute the plain SQL statement with results (e.g: SELECT, etc...)
      Parameters:
      statement - the plain SQL statement with results
      adapter - the result adapter
      Returns:
    • batch

      public void batch(Function<org.jooq.DSLContext,org.jooq.Query> queryFunction, BindBatchValues bindBatchValues, io.vertx.core.Handler<io.vertx.core.AsyncResult<BatchResult>> handler)
      Batch execute
      Parameters:
      queryFunction - query function
      bindBatchValues - bind batch values
      handler - async result handler
    • batch

      public void batch(Function<org.jooq.DSLContext,org.jooq.Query> queryFunction, BindBatchValues bindBatchValues)
      Batch execute
      Parameters:
      queryFunction - query function
      bindBatchValues - bind batch values
    • rxBatch

      public io.reactivex.Single<BatchResult> rxBatch(Function<org.jooq.DSLContext,org.jooq.Query> queryFunction, BindBatchValues bindBatchValues)
      Batch execute
      Parameters:
      queryFunction - query function
      bindBatchValues - bind batch values
      Returns:
    • batch

      public void batch(org.jooq.Query query, BindBatchValues bindBatchValues, io.vertx.core.Handler<io.vertx.core.AsyncResult<BatchResult>> handler)
      Batch execute
      Parameters:
      query - query
      bindBatchValues - bind batch values
      handler - async result handler
    • batch

      public void batch(org.jooq.Query query, BindBatchValues bindBatchValues)
      Batch execute
      Parameters:
      query - query
      bindBatchValues - bind batch values
    • rxBatch

      public io.reactivex.Single<BatchResult> rxBatch(org.jooq.Query query, BindBatchValues bindBatchValues)
      Batch execute
      Parameters:
      query - query
      bindBatchValues - bind batch values
      Returns:
    • batchResult

      public <T, R> void batchResult(Function<org.jooq.DSLContext,org.jooq.Query> queryFunction, BindBatchValues bindBatchValues, SQLResultListAdapter<T,R> adapter, io.vertx.core.Handler<io.vertx.core.AsyncResult<BatchReturningResult<R>>> handler)
      Result batch execute
      Parameters:
      queryFunction - query function
      bindBatchValues - bind batch values
      adapter -
      handler - async result handler
    • batchResult

      public <T, R> void batchResult(Function<org.jooq.DSLContext,org.jooq.Query> queryFunction, BindBatchValues bindBatchValues, SQLResultListAdapter<T,R> adapter)
      Result batch execute
      Parameters:
      queryFunction - query function
      bindBatchValues - bind batch values
      adapter -
    • rxBatchResult

      public <T, R> io.reactivex.Single<BatchReturningResult<R>> rxBatchResult(Function<org.jooq.DSLContext,org.jooq.Query> queryFunction, BindBatchValues bindBatchValues, SQLResultListAdapter<T,R> adapter)
      Result batch execute
      Parameters:
      queryFunction - query function
      bindBatchValues - bind batch values
      adapter -
      Returns:
    • batchResult

      public <T, R> void batchResult(org.jooq.Query query, BindBatchValues bindBatchValues, SQLResultListAdapter<T,R> adapter, io.vertx.core.Handler<io.vertx.core.AsyncResult<BatchReturningResult<R>>> handler)
      Execute batch statements then receive results
      Parameters:
      query - jOOQ query
      bindBatchValues - bind batch values
      adapter - result adapter
      handler - async result handler
    • batchResult

      public <T, R> void batchResult(org.jooq.Query query, BindBatchValues bindBatchValues, SQLResultListAdapter<T,R> adapter)
      Execute batch statements then receive results
      Parameters:
      query - jOOQ query
      bindBatchValues - bind batch values
      adapter - result adapter
    • rxBatchResult

      public <T, R> io.reactivex.Single<BatchReturningResult<R>> rxBatchResult(org.jooq.Query query, BindBatchValues bindBatchValues, SQLResultListAdapter<T,R> adapter)
      Execute batch statements then receive results
      Parameters:
      query - jOOQ query
      bindBatchValues - bind batch values
      adapter - result adapter
      Returns:
    • routine

      public <T> void routine(Function<org.jooq.DSLContext,org.jooq.Routine<T>> routineFunction, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>> handler)
    • routine

      public <T> void routine(Function<org.jooq.DSLContext,org.jooq.Routine<T>> routineFunction)
    • rxRoutine

      public <T> io.reactivex.Single<T> rxRoutine(Function<org.jooq.DSLContext,org.jooq.Routine<T>> routineFunction)
    • routine

      public <T> io.vertx.core.Future<T> routine(org.jooq.Routine<T> routine, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>> handler)
    • routineResult

      public <T> void routineResult(org.jooq.Routine<T> routine, io.vertx.core.Handler<io.vertx.core.AsyncResult<RoutineResult>> handler)
    • routineResult

      public <T> void routineResult(org.jooq.Routine<T> routine)
    • rxRoutineResult

      public <T> io.reactivex.Single<RoutineResult> rxRoutineResult(org.jooq.Routine<T> routine)
    • routineResultSet

      public <T, X, R> io.vertx.core.Future<R> routineResultSet(org.jooq.Routine<T> routine, SQLResultAdapter<X,R> resultAdapter, io.vertx.core.Handler<io.vertx.core.AsyncResult<R>> handler)
    • dsl

      public org.jooq.DSLContext dsl()
    • errorConverter

      public SQLErrorConverter errorConverter()
    • typeMapperRegistry

      public DataTypeMapperRegistry typeMapperRegistry()
    • newInstance

      public static Jooqx newInstance(Jooqx arg)