io.vertx.rxjava.ext.sql

## Class SQLConnection

- java.lang.Object
- - io.vertx.rxjava.ext.sql.SQLConnection

- All Implemented Interfaces:
    SQLOperations

      public class SQLConnection
      extends Object
      implements SQLOperations

  Represents a connection to a SQL database

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

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static io.vertx.lang.rx.TypeArg<SQLConnection>` | `__TYPE_ARG`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `SQLConnection(Object delegate)`
    `SQLConnection(SQLConnection delegate)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `SQLConnection` | `batch(List<String> sqlStatements, Handler<AsyncResult<List<Integer>>> handler)` Batch simple SQL strings and execute the batch where the async result contains a array of Integers.
    `SQLConnection` | `batchCallableWithParams(String sqlStatement, List<JsonArray> inArgs, List<JsonArray> outArgs, Handler<AsyncResult<List<Integer>>> handler)` Batch a callable statement with all entries from the args list.
    `Observable<List<Integer>>` | `batchCallableWithParamsObservable(String sqlStatement, List<JsonArray> inArgs, List<JsonArray> outArgs)` Deprecated. use `rxBatchCallableWithParams(java.lang.String, java.util.List<io.vertx.core.json.JsonArray>, java.util.List<io.vertx.core.json.JsonArray>)` instead
    `Observable<List<Integer>>` | `batchObservable(List<String> sqlStatements)` Deprecated. use `rxBatch(java.util.List<java.lang.String>)` instead
    `SQLConnection` | `batchWithParams(String sqlStatement, List<JsonArray> args, Handler<AsyncResult<List<Integer>>> handler)` Batch a prepared statement with all entries from the args list.
    `Observable<List<Integer>>` | `batchWithParamsObservable(String sqlStatement, List<JsonArray> args)` Deprecated. use `rxBatchWithParams(java.lang.String, java.util.List<io.vertx.core.json.JsonArray>)` instead
    `SQLConnection` | `call(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `Observable<ResultSet>` | `callObservable(String sql)` Deprecated. use `rxCall(java.lang.String)` instead
    `SQLConnection` | `callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `Observable<ResultSet>` | `callWithParamsObservable(String sql, JsonArray params, JsonArray outputs)` Deprecated. use `rxCallWithParams(java.lang.String, io.vertx.core.json.JsonArray, io.vertx.core.json.JsonArray)` instead
    `void` | `close()` Closes the connection.
    `void` | `close(Handler<AsyncResult<Void>> handler)` Closes the connection.
    `Observable<Void>` | `closeObservable()` Deprecated. use `rxClose()` instead
    `SQLConnection` | `commit(Handler<AsyncResult<Void>> handler)` Commits all changes made since the previous commit/rollback.
    `Observable<Void>` | `commitObservable()` Deprecated. use `rxCommit()` instead
    `boolean` | `equals(Object o)`
    `SQLConnection` | `execute(String sql, Handler<AsyncResult<Void>> resultHandler)` Executes the given SQL statement
    `Observable<Void>` | `executeObservable(String sql)` Deprecated. use `rxExecute(java.lang.String)` instead
    `SQLConnection` | `getDelegate()`
    `SQLConnection` | `getTransactionIsolation(Handler<AsyncResult<TransactionIsolation>> handler)` Attempts to return the transaction isolation level for this Connection object to the one given.
    `Observable<TransactionIsolation>` | `getTransactionIsolationObservable()` Deprecated. use `rxGetTransactionIsolation()` instead
    `int` | `hashCode()`
    `static SQLConnection` | `newInstance(SQLConnection arg)`
    `SQLConnection` | `query(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` statement which returns the results of the query.
    `Observable<ResultSet>` | `queryObservable(String sql)` Deprecated. use `rxQuery(java.lang.String)` instead
    `SQLOperations` | `querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `Observable<JsonArray>` | `querySingleObservable(String sql)` Deprecated. use `rxQuerySingle(java.lang.String)` instead
    `SQLOperations` | `querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `Observable<JsonArray>` | `querySingleWithParamsObservable(String sql, JsonArray arguments)` Deprecated. use `rxQuerySingleWithParams(java.lang.String, io.vertx.core.json.JsonArray)` instead
    `SQLConnection` | `queryStream(String sql, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `Observable<SQLRowStream>` | `queryStreamObservable(String sql)` Deprecated. use `rxQueryStream(java.lang.String)` instead
    `SQLConnection` | `queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `Observable<SQLRowStream>` | `queryStreamWithParamsObservable(String sql, JsonArray params)` Deprecated. use `rxQueryStreamWithParams(java.lang.String, io.vertx.core.json.JsonArray)` instead
    `SQLConnection` | `queryWithParams(String sql, JsonArray params, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` prepared statement which returns the results of the query.
    `Observable<ResultSet>` | `queryWithParamsObservable(String sql, JsonArray params)` Deprecated. use `rxQueryWithParams(java.lang.String, io.vertx.core.json.JsonArray)` instead
    `SQLConnection` | `rollback(Handler<AsyncResult<Void>> handler)` Rolls back all changes made since the previous commit/rollback.
    `Observable<Void>` | `rollbackObservable()` Deprecated. use `rxRollback()` instead
    `Single<List<Integer>>` | `rxBatch(List<String> sqlStatements)` Batch simple SQL strings and execute the batch where the async result contains a array of Integers.
    `Single<List<Integer>>` | `rxBatchCallableWithParams(String sqlStatement, List<JsonArray> inArgs, List<JsonArray> outArgs)` Batch a callable statement with all entries from the args list.
    `Single<List<Integer>>` | `rxBatchWithParams(String sqlStatement, List<JsonArray> args)` Batch a prepared statement with all entries from the args list.
    `Single<ResultSet>` | `rxCall(String sql)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `Single<ResultSet>` | `rxCallWithParams(String sql, JsonArray params, JsonArray outputs)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `Single<Void>` | `rxClose()` Closes the connection.
    `Single<Void>` | `rxCommit()` Commits all changes made since the previous commit/rollback.
    `Single<Void>` | `rxExecute(String sql)` Executes the given SQL statement
    `Single<TransactionIsolation>` | `rxGetTransactionIsolation()` Attempts to return the transaction isolation level for this Connection object to the one given.
    `Single<ResultSet>` | `rxQuery(String sql)` Executes the given SQL `SELECT` statement which returns the results of the query.
    `Single<JsonArray>` | `rxQuerySingle(String sql)` Execute a one shot SQL statement that returns a single SQL row.
    `Single<JsonArray>` | `rxQuerySingleWithParams(String sql, JsonArray arguments)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `Single<SQLRowStream>` | `rxQueryStream(String sql)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `Single<SQLRowStream>` | `rxQueryStreamWithParams(String sql, JsonArray params)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `Single<ResultSet>` | `rxQueryWithParams(String sql, JsonArray params)` Executes the given SQL `SELECT` prepared statement which returns the results of the query.
    `Single<Void>` | `rxRollback()` Rolls back all changes made since the previous commit/rollback.
    `Single<Void>` | `rxSetAutoCommit(boolean autoCommit)` Sets the auto commit flag for this connection.
    `Single<Void>` | `rxSetTransactionIsolation(TransactionIsolation isolation)` Attempts to change the transaction isolation level for this Connection object to the one given.
    `Single<UpdateResult>` | `rxUpdate(String sql)` Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
    `Single<UpdateResult>` | `rxUpdateWithParams(String sql, JsonArray params)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
    `SQLConnection` | `setAutoCommit(boolean autoCommit, Handler<AsyncResult<Void>> resultHandler)` Sets the auto commit flag for this connection.
    `Observable<Void>` | `setAutoCommitObservable(boolean autoCommit)` Deprecated. use `rxSetAutoCommit(boolean)` instead
    `SQLConnection` | `setOptions(SQLOptions options)` Sets the desired options to be applied to the current connection when statements are executed.
    `SQLConnection` | `setQueryTimeout(int timeoutInSeconds)` Deprecated.
    `SQLConnection` | `setTransactionIsolation(TransactionIsolation isolation, Handler<AsyncResult<Void>> handler)` Attempts to change the transaction isolation level for this Connection object to the one given.
    `Observable<Void>` | `setTransactionIsolationObservable(TransactionIsolation isolation)` Deprecated. use `rxSetTransactionIsolation(io.vertx.ext.sql.TransactionIsolation)` instead
    `String` | `toString()`
    `SQLConnection` | `update(String sql, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
    `Observable<UpdateResult>` | `updateObservable(String sql)` Deprecated. use `rxUpdate(java.lang.String)` instead
    `SQLConnection` | `updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
    `Observable<UpdateResult>` | `updateWithParamsObservable(String sql, JsonArray params)` Deprecated. use `rxUpdateWithParams(java.lang.String, io.vertx.core.json.JsonArray)` instead

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface io.vertx.rxjava.ext.sql.SQLOperations

      `newInstance`

- - ### Field Detail

    - #### __TYPE_ARG

          public static final io.vertx.lang.rx.TypeArg<SQLConnection> __TYPE_ARG

  - ### Constructor Detail

    - #### SQLConnection

          public SQLConnection(SQLConnection delegate)

    - #### SQLConnection

          public SQLConnection(Object delegate)

  - ### Method Detail

    - #### 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 SQLConnection getDelegate()

      Specified by:
        `getDelegate` in interface `SQLOperations`

    - #### querySingle

          public SQLOperations querySingle(String sql,
                                           Handler<AsyncResult<JsonArray>> handler)

      Execute a one shot SQL statement that returns a single SQL row. This method will reduce the boilerplate code by getting a connection from the pool (this object) and return it back after the execution. Only the first result from the result set is returned.
      Specified by:
        `querySingle` in interface `SQLOperations`
      Parameters:
        `sql` - the statement to execute
        `handler` - the result handler
      Returns:
        self

    - #### querySingleObservable

          @Deprecated
          public Observable<JsonArray> querySingleObservable(String sql)

      Deprecated. use `rxQuerySingle(java.lang.String)` instead
      Execute a one shot SQL statement that returns a single SQL row. This method will reduce the boilerplate code by getting a connection from the pool (this object) and return it back after the execution. Only the first result from the result set is returned.
      Parameters:
        `sql` - the statement to execute
      Returns:
        self

    - #### rxQuerySingle

          public Single<JsonArray> rxQuerySingle(String sql)

      Execute a one shot SQL statement that returns a single SQL row. This method will reduce the boilerplate code by getting a connection from the pool (this object) and return it back after the execution. Only the first result from the result set is returned.
      Parameters:
        `sql` - the statement to execute
      Returns:
        self

    - #### querySingleWithParams

          public SQLOperations querySingleWithParams(String sql,
                                                     JsonArray arguments,
                                                     Handler<AsyncResult<JsonArray>> handler)

      Execute a one shot SQL statement with arguments that returns a single SQL row. This method will reduce the boilerplate code by getting a connection from the pool (this object) and return it back after the execution. Only the first result from the result set is returned.
      Specified by:
        `querySingleWithParams` in interface `SQLOperations`
      Parameters:
        `sql` - the statement to execute
        `arguments` - the arguments
        `handler` - the result handler
      Returns:
        self

    - #### querySingleWithParamsObservable

          @Deprecated
          public Observable<JsonArray> querySingleWithParamsObservable(String sql,
                                                                                   JsonArray arguments)

      Deprecated. use `rxQuerySingleWithParams(java.lang.String, io.vertx.core.json.JsonArray)` instead
      Execute a one shot SQL statement with arguments that returns a single SQL row. This method will reduce the boilerplate code by getting a connection from the pool (this object) and return it back after the execution. Only the first result from the result set is returned.
      Parameters:
        `sql` - the statement to execute
        `arguments` - the arguments
      Returns:
        self

    - #### rxQuerySingleWithParams

          public Single<JsonArray> rxQuerySingleWithParams(String sql,
                                                           JsonArray arguments)

      Execute a one shot SQL statement with arguments that returns a single SQL row. This method will reduce the boilerplate code by getting a connection from the pool (this object) and return it back after the execution. Only the first result from the result set is returned.
      Parameters:
        `sql` - the statement to execute
        `arguments` - the arguments
      Returns:
        self

    - #### setOptions

          public SQLConnection setOptions(SQLOptions options)

      Sets the desired options to be applied to the current connection when statements are executed. The options are not applied globally but applicable to the current connection. For example changing the transaction isolation level will only affect statements run on this connection and not future or current connections acquired from the connection pool. This method is not async in nature since the apply will only happen at the moment a query is run.
      Parameters:
        `options` - the options to modify the unwrapped connection.
      Returns:

    - #### setAutoCommit

          public SQLConnection setAutoCommit(boolean autoCommit,
                                             Handler<AsyncResult<Void>> resultHandler)

      Sets the auto commit flag for this connection. True by default.
      Parameters:
        `autoCommit` - the autoCommit flag, true by default.
        `resultHandler` - the handler which is called once this operation completes.
      Returns:

    - #### setAutoCommitObservable

          @Deprecated
          public Observable<Void> setAutoCommitObservable(boolean autoCommit)

      Deprecated. use `rxSetAutoCommit(boolean)` instead
      Sets the auto commit flag for this connection. True by default.
      Parameters:
        `autoCommit` - the autoCommit flag, true by default.
      Returns:

    - #### rxSetAutoCommit

          public Single<Void> rxSetAutoCommit(boolean autoCommit)

      Sets the auto commit flag for this connection. True by default.
      Parameters:
        `autoCommit` - the autoCommit flag, true by default.
      Returns:

    - #### execute

          public SQLConnection execute(String sql,
                                       Handler<AsyncResult<Void>> resultHandler)

      Executes the given SQL statement
      Parameters:
        `sql` - the SQL to execute. For example `CREATE TABLE IF EXISTS table ...`
        `resultHandler` - the handler which is called once this operation completes.
      Returns:

    - #### executeObservable

          @Deprecated
          public Observable<Void> executeObservable(String sql)

      Deprecated. use `rxExecute(java.lang.String)` instead
      Executes the given SQL statement
      Parameters:
        `sql` - the SQL to execute. For example `CREATE TABLE IF EXISTS table ...`
      Returns:

    - #### rxExecute

          public Single<Void> rxExecute(String sql)

      Executes the given SQL statement
      Parameters:
        `sql` - the SQL to execute. For example `CREATE TABLE IF EXISTS table ...`
      Returns:

    - #### query

          public SQLConnection query(String sql,
                                     Handler<AsyncResult<ResultSet>> resultHandler)

      Executes the given SQL `SELECT` statement which returns the results of the query.
      Specified by:
        `query` in interface `SQLOperations`
      Parameters:
        `sql` - the SQL to execute. For example `SELECT * FROM table ...`.
        `resultHandler` - the handler which is called once the operation completes. It will return a `ResultSet`.
      Returns:

    - #### queryObservable

          @Deprecated
          public Observable<ResultSet> queryObservable(String sql)

      Deprecated. use `rxQuery(java.lang.String)` instead
      Executes the given SQL `SELECT` statement which returns the results of the query.
      Parameters:
        `sql` - the SQL to execute. For example `SELECT * FROM table ...`.
      Returns:

    - #### rxQuery

          public Single<ResultSet> rxQuery(String sql)

      Executes the given SQL `SELECT` statement which returns the results of the query.
      Parameters:
        `sql` - the SQL to execute. For example `SELECT * FROM table ...`.
      Returns:

    - #### queryStream

          public SQLConnection queryStream(String sql,
                                           Handler<AsyncResult<SQLRowStream>> handler)

      Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
      Specified by:
        `queryStream` in interface `SQLOperations`
      Parameters:
        `sql` - the SQL to execute. For example `SELECT * FROM table ...`.
        `handler` - the handler which is called once the operation completes. It will return a `SQLRowStream`.
      Returns:

    - #### queryStreamObservable

          @Deprecated
          public Observable<SQLRowStream> queryStreamObservable(String sql)

      Deprecated. use `rxQueryStream(java.lang.String)` instead
      Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
      Parameters:
        `sql` - the SQL to execute. For example `SELECT * FROM table ...`.
      Returns:

    - #### rxQueryStream

          public Single<SQLRowStream> rxQueryStream(String sql)

      Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
      Parameters:
        `sql` - the SQL to execute. For example `SELECT * FROM table ...`.
      Returns:

    - #### queryWithParams

          public SQLConnection queryWithParams(String sql,
                                               JsonArray params,
                                               Handler<AsyncResult<ResultSet>> resultHandler)

      Executes the given SQL `SELECT` prepared statement which returns the results of the query.
      Specified by:
        `queryWithParams` in interface `SQLOperations`
      Parameters:
        `sql` - the SQL to execute. For example `SELECT * FROM table ...`.
        `params` - these are the parameters to fill the statement.
        `resultHandler` - the handler which is called once the operation completes. It will return a `ResultSet`.
      Returns:

    - #### queryWithParamsObservable

          @Deprecated
          public Observable<ResultSet> queryWithParamsObservable(String sql,
                                                                             JsonArray params)

      Deprecated. use `rxQueryWithParams(java.lang.String, io.vertx.core.json.JsonArray)` instead
      Executes the given SQL `SELECT` prepared statement which returns the results of the query.
      Parameters:
        `sql` - the SQL to execute. For example `SELECT * FROM table ...`.
        `params` - these are the parameters to fill the statement.
      Returns:

    - #### rxQueryWithParams

          public Single<ResultSet> rxQueryWithParams(String sql,
                                                     JsonArray params)

      Executes the given SQL `SELECT` prepared statement which returns the results of the query.
      Parameters:
        `sql` - the SQL to execute. For example `SELECT * FROM table ...`.
        `params` - these are the parameters to fill the statement.
      Returns:

    - #### queryStreamWithParams

          public SQLConnection queryStreamWithParams(String sql,
                                                     JsonArray params,
                                                     Handler<AsyncResult<SQLRowStream>> handler)

      Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
      Specified by:
        `queryStreamWithParams` in interface `SQLOperations`
      Parameters:
        `sql` - the SQL to execute. For example `SELECT * FROM table ...`.
        `params` - these are the parameters to fill the statement.
        `handler` - the handler which is called once the operation completes. It will return a `SQLRowStream`.
      Returns:

    - #### queryStreamWithParamsObservable

          @Deprecated
          public Observable<SQLRowStream> queryStreamWithParamsObservable(String sql,
                                                                                      JsonArray params)

      Deprecated. use `rxQueryStreamWithParams(java.lang.String, io.vertx.core.json.JsonArray)` instead
      Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
      Parameters:
        `sql` - the SQL to execute. For example `SELECT * FROM table ...`.
        `params` - these are the parameters to fill the statement.
      Returns:

    - #### rxQueryStreamWithParams

          public Single<SQLRowStream> rxQueryStreamWithParams(String sql,
                                                              JsonArray params)

      Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
      Parameters:
        `sql` - the SQL to execute. For example `SELECT * FROM table ...`.
        `params` - these are the parameters to fill the statement.
      Returns:

    - #### update

          public SQLConnection update(String sql,
                                      Handler<AsyncResult<UpdateResult>> resultHandler)

      Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
      Specified by:
        `update` in interface `SQLOperations`
      Parameters:
        `sql` - the SQL to execute. For example `INSERT INTO table ...`
        `resultHandler` - the handler which is called once the operation completes.
      Returns:

    - #### updateObservable

          @Deprecated
          public Observable<UpdateResult> updateObservable(String sql)

      Deprecated. use `rxUpdate(java.lang.String)` instead
      Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
      Parameters:
        `sql` - the SQL to execute. For example `INSERT INTO table ...`
      Returns:

    - #### rxUpdate

          public Single<UpdateResult> rxUpdate(String sql)

      Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
      Parameters:
        `sql` - the SQL to execute. For example `INSERT INTO table ...`
      Returns:

    - #### updateWithParams

          public SQLConnection updateWithParams(String sql,
                                                JsonArray params,
                                                Handler<AsyncResult<UpdateResult>> resultHandler)

      Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
      Specified by:
        `updateWithParams` in interface `SQLOperations`
      Parameters:
        `sql` - the SQL to execute. For example `INSERT INTO table ...`
        `params` - these are the parameters to fill the statement.
        `resultHandler` - the handler which is called once the operation completes.
      Returns:

    - #### updateWithParamsObservable

          @Deprecated
          public Observable<UpdateResult> updateWithParamsObservable(String sql,
                                                                                 JsonArray params)

      Deprecated. use `rxUpdateWithParams(java.lang.String, io.vertx.core.json.JsonArray)` instead
      Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
      Parameters:
        `sql` - the SQL to execute. For example `INSERT INTO table ...`
        `params` - these are the parameters to fill the statement.
      Returns:

    - #### rxUpdateWithParams

          public Single<UpdateResult> rxUpdateWithParams(String sql,
                                                         JsonArray params)

      Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
      Parameters:
        `sql` - the SQL to execute. For example `INSERT INTO table ...`
        `params` - these are the parameters to fill the statement.
      Returns:

    - #### call

          public SQLConnection call(String sql,
                                    Handler<AsyncResult<ResultSet>> resultHandler)

      Calls the given SQL `PROCEDURE` which returns the result from the procedure.
      Specified by:
        `call` in interface `SQLOperations`
      Parameters:
        `sql` - the SQL to execute. For example `{call getEmpName}`.
        `resultHandler` - the handler which is called once the operation completes. It will return a `ResultSet`.
      Returns:

    - #### callObservable

          @Deprecated
          public Observable<ResultSet> callObservable(String sql)

      Deprecated. use `rxCall(java.lang.String)` instead
      Calls the given SQL `PROCEDURE` which returns the result from the procedure.
      Parameters:
        `sql` - the SQL to execute. For example `{call getEmpName}`.
      Returns:

    - #### rxCall

          public Single<ResultSet> rxCall(String sql)

      Calls the given SQL `PROCEDURE` which returns the result from the procedure.
      Parameters:
        `sql` - the SQL to execute. For example `{call getEmpName}`.
      Returns:

    - #### callWithParams

          public SQLConnection callWithParams(String sql,
                                              JsonArray params,
                                              JsonArray outputs,
                                              Handler<AsyncResult<ResultSet>> resultHandler)

      Calls the given SQL `PROCEDURE` which returns the result from the procedure. The index of params and outputs are important for both arrays, for example when dealing with a prodecure that takes the first 2 arguments as input values and the 3 arg as an output then the arrays should be like:

             params = [VALUE1, VALUE2, null]
             outputs = [null, null, "VARCHAR"]

      Specified by:
        `callWithParams` in interface `SQLOperations`
      Parameters:
        `sql` - the SQL to execute. For example `{call getEmpName (?, ?)}`.
        `params` - these are the parameters to fill the statement.
        `outputs` - these are the outputs to fill the statement.
        `resultHandler` - the handler which is called once the operation completes. It will return a `ResultSet`.
      Returns:

    - #### callWithParamsObservable

          @Deprecated
          public Observable<ResultSet> callWithParamsObservable(String sql,
                                                                            JsonArray params,
                                                                            JsonArray outputs)

      Deprecated. use `rxCallWithParams(java.lang.String, io.vertx.core.json.JsonArray, io.vertx.core.json.JsonArray)` instead
      Calls the given SQL `PROCEDURE` which returns the result from the procedure. The index of params and outputs are important for both arrays, for example when dealing with a prodecure that takes the first 2 arguments as input values and the 3 arg as an output then the arrays should be like:

             params = [VALUE1, VALUE2, null]
             outputs = [null, null, "VARCHAR"]

      Parameters:
        `sql` - the SQL to execute. For example `{call getEmpName (?, ?)}`.
        `params` - these are the parameters to fill the statement.
        `outputs` - these are the outputs to fill the statement.
      Returns:

    - #### rxCallWithParams

          public Single<ResultSet> rxCallWithParams(String sql,
                                                    JsonArray params,
                                                    JsonArray outputs)

      Calls the given SQL `PROCEDURE` which returns the result from the procedure. The index of params and outputs are important for both arrays, for example when dealing with a prodecure that takes the first 2 arguments as input values and the 3 arg as an output then the arrays should be like:

             params = [VALUE1, VALUE2, null]
             outputs = [null, null, "VARCHAR"]

      Parameters:
        `sql` - the SQL to execute. For example `{call getEmpName (?, ?)}`.
        `params` - these are the parameters to fill the statement.
        `outputs` - these are the outputs to fill the statement.
      Returns:

    - #### close

          public void close(Handler<AsyncResult<Void>> handler)

      Closes the connection. Important to always close the connection when you are done so it's returned to the pool.
      Parameters:
        `handler` - the handler called when this operation completes.

    - #### closeObservable

          @Deprecated
          public Observable<Void> closeObservable()

      Deprecated. use `rxClose()` instead
      Closes the connection. Important to always close the connection when you are done so it's returned to the pool.
      Returns:

    - #### rxClose

          public Single<Void> rxClose()

      Closes the connection. Important to always close the connection when you are done so it's returned to the pool.
      Returns:

    - #### close

          public void close()

      Closes the connection. Important to always close the connection when you are done so it's returned to the pool.

    - #### commit

          public SQLConnection commit(Handler<AsyncResult<Void>> handler)

      Commits all changes made since the previous commit/rollback.
      Parameters:
        `handler` - the handler called when this operation completes.
      Returns:

    - #### commitObservable

          @Deprecated
          public Observable<Void> commitObservable()

      Deprecated. use `rxCommit()` instead
      Commits all changes made since the previous commit/rollback.
      Returns:

    - #### rxCommit

          public Single<Void> rxCommit()

      Commits all changes made since the previous commit/rollback.
      Returns:

    - #### rollback

          public SQLConnection rollback(Handler<AsyncResult<Void>> handler)

      Rolls back all changes made since the previous commit/rollback.
      Parameters:
        `handler` - the handler called when this operation completes.
      Returns:

    - #### rollbackObservable

          @Deprecated
          public Observable<Void> rollbackObservable()

      Deprecated. use `rxRollback()` instead
      Rolls back all changes made since the previous commit/rollback.
      Returns:

    - #### rxRollback

          public Single<Void> rxRollback()

      Rolls back all changes made since the previous commit/rollback.
      Returns:

    - #### setQueryTimeout

          @Deprecated
          public SQLConnection setQueryTimeout(int timeoutInSeconds)

      Deprecated.
      Sets a connection wide query timeout. It can be over written at any time and becomes active on the next query call.
      Parameters:
        `timeoutInSeconds` - the max amount of seconds the query can take to execute.
      Returns:

    - #### batch

          public SQLConnection batch(List<String> sqlStatements,
                                     Handler<AsyncResult<List<Integer>>> handler)

      Batch simple SQL strings and execute the batch where the async result contains a array of Integers.
      Parameters:
        `sqlStatements` - sql statement
        `handler` - the result handler
      Returns:

    - #### batchObservable

          @Deprecated
          public Observable<List<Integer>> batchObservable(List<String> sqlStatements)

      Deprecated. use `rxBatch(java.util.List<java.lang.String>)` instead
      Batch simple SQL strings and execute the batch where the async result contains a array of Integers.
      Parameters:
        `sqlStatements` - sql statement
      Returns:

    - #### rxBatch

          public Single<List<Integer>> rxBatch(List<String> sqlStatements)

      Batch simple SQL strings and execute the batch where the async result contains a array of Integers.
      Parameters:
        `sqlStatements` - sql statement
      Returns:

    - #### batchWithParams

          public SQLConnection batchWithParams(String sqlStatement,
                                               List<JsonArray> args,
                                               Handler<AsyncResult<List<Integer>>> handler)

      Batch a prepared statement with all entries from the args list. Each entry is a batch. The operation completes with the execution of the batch where the async result contains a array of Integers.
      Parameters:
        `sqlStatement` - sql statement
        `args` - the prepared statement arguments
        `handler` - the result handler
      Returns:

    - #### batchWithParamsObservable

          @Deprecated
          public Observable<List<Integer>> batchWithParamsObservable(String sqlStatement,
                                                                                 List<JsonArray> args)

      Deprecated. use `rxBatchWithParams(java.lang.String, java.util.List<io.vertx.core.json.JsonArray>)` instead
      Batch a prepared statement with all entries from the args list. Each entry is a batch. The operation completes with the execution of the batch where the async result contains a array of Integers.
      Parameters:
        `sqlStatement` - sql statement
        `args` - the prepared statement arguments
      Returns:

    - #### rxBatchWithParams

          public Single<List<Integer>> rxBatchWithParams(String sqlStatement,
                                                         List<JsonArray> args)

      Batch a prepared statement with all entries from the args list. Each entry is a batch. The operation completes with the execution of the batch where the async result contains a array of Integers.
      Parameters:
        `sqlStatement` - sql statement
        `args` - the prepared statement arguments
      Returns:

    - #### batchCallableWithParams

          public SQLConnection batchCallableWithParams(String sqlStatement,
                                                       List<JsonArray> inArgs,
                                                       List<JsonArray> outArgs,
                                                       Handler<AsyncResult<List<Integer>>> handler)

      Batch a callable statement with all entries from the args list. Each entry is a batch. The size of the lists inArgs and outArgs MUST be the equal. The operation completes with the execution of the batch where the async result contains a array of Integers.
      Parameters:
        `sqlStatement` - sql statement
        `inArgs` - the callable statement input arguments
        `outArgs` - the callable statement output arguments
        `handler` - the result handler
      Returns:

    - #### batchCallableWithParamsObservable

          @Deprecated
          public Observable<List<Integer>> batchCallableWithParamsObservable(String sqlStatement,
                                                                                         List<JsonArray> inArgs,
                                                                                         List<JsonArray> outArgs)

      Deprecated. use `rxBatchCallableWithParams(java.lang.String, java.util.List<io.vertx.core.json.JsonArray>, java.util.List<io.vertx.core.json.JsonArray>)` instead
      Batch a callable statement with all entries from the args list. Each entry is a batch. The size of the lists inArgs and outArgs MUST be the equal. The operation completes with the execution of the batch where the async result contains a array of Integers.
      Parameters:
        `sqlStatement` - sql statement
        `inArgs` - the callable statement input arguments
        `outArgs` - the callable statement output arguments
      Returns:

    - #### rxBatchCallableWithParams

          public Single<List<Integer>> rxBatchCallableWithParams(String sqlStatement,
                                                                 List<JsonArray> inArgs,
                                                                 List<JsonArray> outArgs)

      Batch a callable statement with all entries from the args list. Each entry is a batch. The size of the lists inArgs and outArgs MUST be the equal. The operation completes with the execution of the batch where the async result contains a array of Integers.
      Parameters:
        `sqlStatement` - sql statement
        `inArgs` - the callable statement input arguments
        `outArgs` - the callable statement output arguments
      Returns:

    - #### setTransactionIsolation

          public SQLConnection setTransactionIsolation(TransactionIsolation isolation,
                                                       Handler<AsyncResult<Void>> handler)

      Attempts to change the transaction isolation level for this Connection object to the one given. The constants defined in the interface Connection are the possible transaction isolation levels.
      Parameters:
        `isolation` - the level of isolation
        `handler` - the handler called when this operation completes.
      Returns:

    - #### setTransactionIsolationObservable

          @Deprecated
          public Observable<Void> setTransactionIsolationObservable(TransactionIsolation isolation)

      Deprecated. use `rxSetTransactionIsolation(io.vertx.ext.sql.TransactionIsolation)` instead
      Attempts to change the transaction isolation level for this Connection object to the one given. The constants defined in the interface Connection are the possible transaction isolation levels.
      Parameters:
        `isolation` - the level of isolation
      Returns:

    - #### rxSetTransactionIsolation

          public Single<Void> rxSetTransactionIsolation(TransactionIsolation isolation)

      Attempts to change the transaction isolation level for this Connection object to the one given. The constants defined in the interface Connection are the possible transaction isolation levels.
      Parameters:
        `isolation` - the level of isolation
      Returns:

    - #### getTransactionIsolation

          public SQLConnection getTransactionIsolation(Handler<AsyncResult<TransactionIsolation>> handler)

      Attempts to return the transaction isolation level for this Connection object to the one given.
      Parameters:
        `handler` - the handler called when this operation completes.
      Returns:

    - #### getTransactionIsolationObservable

          @Deprecated
          public Observable<TransactionIsolation> getTransactionIsolationObservable()

      Deprecated. use `rxGetTransactionIsolation()` instead
      Attempts to return the transaction isolation level for this Connection object to the one given.
      Returns:

    - #### rxGetTransactionIsolation

          public Single<TransactionIsolation> rxGetTransactionIsolation()

      Attempts to return the transaction isolation level for this Connection object to the one given.
      Returns:

    - #### newInstance

          public static SQLConnection newInstance(SQLConnection arg)

Copyright © 2022 Eclipse. All rights reserved.