io.vertx.rxjava.ext.sql

## Class SQLConnection

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

-     public class SQLConnection
      extends Object

  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 TypeArg<SQLConnection>` | `__TYPE_ARG`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `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.
    `rx.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
    `rx.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.
    `rx.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.
    `rx.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.
    `rx.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.
    `rx.Observable<Void>` | `closeObservable()` Deprecated. use `rxClose()` instead
    `SQLConnection` | `commit(Handler<AsyncResult<Void>> handler)` Commits all changes made since the previous commit/rollback.
    `rx.Observable<Void>` | `commitObservable()` Deprecated. use `rxCommit()` instead
    `SQLConnection` | `execute(String sql, Handler<AsyncResult<Void>> resultHandler)` Executes the given SQL statement
    `rx.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.
    `rx.Observable<TransactionIsolation>` | `getTransactionIsolationObservable()` Deprecated. use `rxGetTransactionIsolation()` instead
    `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.
    `rx.Observable<ResultSet>` | `queryObservable(String sql)` Deprecated. use `rxQuery(java.lang.String)` 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.
    `rx.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.
    `rx.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.
    `rx.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.
    `rx.Observable<Void>` | `rollbackObservable()` Deprecated. use `rxRollback()` instead
    `rx.Single<List<Integer>>` | `rxBatch(List<String> sqlStatements)` Batch simple SQL strings and execute the batch where the async result contains a array of Integers.
    `rx.Single<List<Integer>>` | `rxBatchCallableWithParams(String sqlStatement, List<JsonArray> inArgs, List<JsonArray> outArgs)` Batch a callable statement with all entries from the args list.
    `rx.Single<List<Integer>>` | `rxBatchWithParams(String sqlStatement, List<JsonArray> args)` Batch a prepared statement with all entries from the args list.
    `rx.Single<ResultSet>` | `rxCall(String sql)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `rx.Single<ResultSet>` | `rxCallWithParams(String sql, JsonArray params, JsonArray outputs)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `rx.Single<Void>` | `rxClose()` Closes the connection.
    `rx.Single<Void>` | `rxCommit()` Commits all changes made since the previous commit/rollback.
    `rx.Single<Void>` | `rxExecute(String sql)` Executes the given SQL statement
    `rx.Single<TransactionIsolation>` | `rxGetTransactionIsolation()` Attempts to return the transaction isolation level for this Connection object to the one given.
    `rx.Single<ResultSet>` | `rxQuery(String sql)` Executes the given SQL `SELECT` statement which returns the results of the query.
    `rx.Single<SQLRowStream>` | `rxQueryStream(String sql)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `rx.Single<SQLRowStream>` | `rxQueryStreamWithParams(String sql, JsonArray params)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `rx.Single<ResultSet>` | `rxQueryWithParams(String sql, JsonArray params)` Executes the given SQL `SELECT` prepared statement which returns the results of the query.
    `rx.Single<Void>` | `rxRollback()` Rolls back all changes made since the previous commit/rollback.
    `rx.Single<Void>` | `rxSetAutoCommit(boolean autoCommit)` Sets the auto commit flag for this connection.
    `rx.Single<Void>` | `rxSetTransactionIsolation(TransactionIsolation isolation)` Attempts to change the transaction isolation level for this Connection object to the one given.
    `rx.Single<UpdateResult>` | `rxUpdate(String sql)` Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
    `rx.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.
    `rx.Observable<Void>` | `setAutoCommitObservable(boolean autoCommit)` Deprecated. use `rxSetAutoCommit(boolean)` instead
    `SQLConnection` | `setQueryTimeout(int timeoutInSeconds)` Sets a connection wide query timeout.
    `SQLConnection` | `setTransactionIsolation(TransactionIsolation isolation, Handler<AsyncResult<Void>> handler)` Attempts to change the transaction isolation level for this Connection object to the one given.
    `rx.Observable<Void>` | `setTransactionIsolationObservable(TransactionIsolation isolation)` Deprecated. use `rxSetTransactionIsolation(io.vertx.ext.sql.TransactionIsolation)` instead
    `SQLConnection` | `update(String sql, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
    `rx.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
    `rx.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, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### __TYPE_ARG

          public static final TypeArg<SQLConnection> __TYPE_ARG

  - ### Constructor Detail

    - #### SQLConnection

          public SQLConnection(SQLConnection delegate)

  - ### Method Detail

    - #### getDelegate

          public SQLConnection getDelegate()

    - #### 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 rx.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 rx.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 rx.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 rx.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.
      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 rx.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 rx.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.
      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 rx.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 rx.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.
      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 rx.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 rx.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.
      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 rx.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 rx.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.
      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 rx.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 rx.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
      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 rx.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 rx.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.
      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 rx.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 rx.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"]

      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 rx.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 rx.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 rx.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 rx.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 rx.Observable<Void> commitObservable()

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

    - #### rxCommit

          public rx.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 rx.Observable<Void> rollbackObservable()

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

    - #### rxRollback

          public rx.Single<Void> rxRollback()

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

    - #### setQueryTimeout

          public SQLConnection setQueryTimeout(int timeoutInSeconds)

      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 rx.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 rx.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 rx.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 rx.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 rx.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 rx.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 rx.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 rx.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 rx.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 rx.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 © 2017. All rights reserved.