SQLConnection (Vert.x Stack - Docs 3.9.15 API)

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

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)

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

Class SQLConnection

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

Field Detail

__TYPE_ARG

Constructor Detail

SQLConnection

SQLConnection

Method Detail

toString

equals

hashCode

getDelegate

querySingle

querySingleObservable

rxQuerySingle

querySingleWithParams

querySingleWithParamsObservable

rxQuerySingleWithParams

setOptions

setAutoCommit

setAutoCommitObservable

rxSetAutoCommit

execute

executeObservable

rxExecute

query

queryObservable

rxQuery

queryStream

queryStreamObservable

rxQueryStream

queryWithParams

queryWithParamsObservable

rxQueryWithParams

queryStreamWithParams

queryStreamWithParamsObservable

rxQueryStreamWithParams

update

updateObservable

rxUpdate

updateWithParams

updateWithParamsObservable

rxUpdateWithParams

call

callObservable

rxCall

callWithParams

callWithParamsObservable

rxCallWithParams

close

closeObservable

rxClose

close

commit

commitObservable

rxCommit

rollback

rollbackObservable

rxRollback

setQueryTimeout

batch

batchObservable

rxBatch

batchWithParams

batchWithParamsObservable

rxBatchWithParams

batchCallableWithParams

batchCallableWithParamsObservable

rxBatchCallableWithParams

setTransactionIsolation

setTransactionIsolationObservable

rxSetTransactionIsolation

getTransactionIsolation

getTransactionIsolationObservable

rxGetTransactionIsolation

newInstance