com.amazon.redshift.jdbc

## Class RedshiftStatementImpl

- java.lang.Object
- - com.amazon.redshift.jdbc.RedshiftStatementImpl

All Implemented Interfaces:
  BaseStatement, RedshiftStatement, AutoCloseable, Statement, Wrapper

    public class RedshiftStatementImpl
    extends Object
    implements Statement, BaseStatement

### Nested Class Summary

Nested Classes
`class` `RedshiftStatementImpl.StatementResultHandler` ResultHandler implementations for updates, queries, and either-or.

### Field Summary

Fields
`protected int` `autoGeneratedKeys`
`protected ArrayList<ParameterList>` `batchParameters`
`protected ArrayList<Query>` `batchStatements`
`protected int` `concurrency`
`protected BaseConnection` `connection`
`protected int` `fetchdirection`
`protected int` `fetchSize` Number of rows to get in a batch.
`protected ResultWrapper` `firstUnclosedResult` The first unclosed result.
`protected ResultWrapper` `generatedKeys` Results returned by a statement that wants generated keys.
`protected int` `maxFieldSize`
`protected int` `maxrows` Maximum number of rows to return, 0 = unlimited.
`protected int` `mPrepareThreshold`
`protected boolean` `replaceProcessingEnabled`
`protected ResultWrapper` `result` The current results.
`protected int` `resultsettype`
`protected long` `timeout` Timeout (in milliseconds) for a query.
`boolean` `wantsGeneratedKeysAlways` Was this PreparedStatement created to return generated keys for every execution? This is set at creation time and never cleared by execution.
`protected boolean` `wantsGeneratedKeysOnce` Does the caller of execute/executeUpdate want generated keys for this execution? This is set by Statement methods that have generated keys arguments and cleared after execution is complete.
`protected com.amazon.redshift.jdbc.RedshiftWarningWrapper` `warnings` The warnings chain.

### Fields inherited from interface com.amazon.redshift.RedshiftStatement

`DATE_NEGATIVE_INFINITY, DATE_NEGATIVE_SMALLER_INFINITY, DATE_POSITIVE_INFINITY, DATE_POSITIVE_SMALLER_INFINITY`

### Fields inherited from interface java.sql.Statement

`CLOSE_ALL_RESULTS, CLOSE_CURRENT_RESULT, EXECUTE_FAILED, KEEP_CURRENT_RESULT, NO_GENERATED_KEYS, RETURN_GENERATED_KEYS, SUCCESS_NO_INFO`

### Method Summary

All Methods Instance Methods Concrete Methods
`void` `addBatch(String sql)`
`void` `addWarning(SQLWarning warn)` Either initializes new warning wrapper, or adds warning onto the chain.
`void` `cancel()`
`protected void` `checkClosed()`
`protected void` `checkCompletion()`
`protected void` `checkNoResultUpdate()`
`void` `clearBatch()`
`void` `clearWarnings()` Clears the warning chain.
`void` `close()` Note: even though `Statement` is automatically closed when it is garbage collected, it is better to close it explicitly to lower resource consumption.
`protected void` `closeForNextExecution()`
`protected void` `closeImpl()` This is guaranteed to be called exactly once even in case of concurrent `close()` calls.
`void` `closeOnCompletion()`
`protected BatchResultHandler` `createBatchHandler(Query[] queries, ParameterList[] parameterLists)`
`ResultSet` `createDriverResultSet(Field[] fields, List<Tuple> tuples)` Create a synthetic resultset from data provided by the driver.
`ResultSet` `createResultSet(Query originalQuery, Field[] fields, List<Tuple> tuples, ResultCursor cursor, RedshiftRowsBlockingQueue<Tuple> queueTuples, int[] rowCount, Thread ringBufferThread)` Create a resultset from data retrieved from the server.
`protected void` `execute(CachedQuery cachedQuery, ParameterList queryParameters, int flags)`
`boolean` `execute(String sql)`
`boolean` `execute(String sql, int autoGeneratedKeys)`
`boolean` `execute(String sql, int[] columnIndexes)`
`boolean` `execute(String sql, String[] columnNames)`
`int[]` `executeBatch()`
`long[]` `executeLargeBatch()`
`long` `executeLargeUpdate(String sql)`
`long` `executeLargeUpdate(String sql, int autoGeneratedKeys)`
`long` `executeLargeUpdate(String sql, int[] columnIndexes)`
`long` `executeLargeUpdate(String sql, String[] columnNames)`
`ResultSet` `executeQuery(String sql)`
`int` `executeUpdate(String sql)`
`int` `executeUpdate(String sql, int autoGeneratedKeys)`
`int` `executeUpdate(String sql, int[] columnIndexes)`
`int` `executeUpdate(String sql, String[] columnNames)`
`boolean` `executeWithFlags(CachedQuery simpleQuery, int flags)` Execute a query, passing additional query flags.
`boolean` `executeWithFlags(int flags)` Execute a prepared query, passing additional query flags.
`boolean` `executeWithFlags(String sql, int flags)` Execute a query, passing additional query flags.
`Connection` `getConnection()`
`int` `getFetchDirection()`
`String` `getFetchingCursorName()`
`int` `getFetchSize()`
`protected boolean` `getForceBinaryTransfer()`
`ResultSet` `getGeneratedKeys()`
`long` `getLargeMaxRows()`
`long` `getLargeUpdateCount()`
`long` `getLastOID()` Returns the Last inserted/updated oid.
`int` `getMaxFieldSize()`
`int` `getMaxRows()`
`boolean` `getMoreResults()`
`boolean` `getMoreResults(int current)`
`int` `getPrepareThreshold()` Gets the server-side prepare reuse threshold in use for this statement.
`int` `getQueryTimeout()`
`long` `getQueryTimeoutMs()` The queryTimeout limit is the number of milliseconds the driver will wait for a Statement to execute.
`BaseConnection` `getRedshiftConnection()`
`ResultSet` `getResultSet()`
`int` `getResultSetConcurrency()`
`int` `getResultSetHoldability()`
`int` `getResultSetType()`
`protected ResultSet` `getSingleResultSet()`
`int` `getUpdateCount()`
`SQLWarning` `getWarnings()`
`boolean` `isClosed()`
`boolean` `isCloseOnCompletion()`
`protected boolean` `isOneShotQuery(CachedQuery cachedQuery)` Returns true if query is unlikely to be reused.
`boolean` `isPoolable()`
`boolean` `isUseServerPrepare()` Checks if this statement will be executed as a server-prepared statement.
`boolean` `isWrapperFor(Class<?> iface)`
`void` `setCursorName(String name)`
`void` `setEscapeProcessing(boolean enable)`
`void` `setFetchDirection(int direction)`
`void` `setFetchSize(int rows)`
`void` `setLargeMaxRows(long max)`
`void` `setMaxFieldSize(int max)`
`void` `setMaxRows(int max)`
`void` `setPoolable(boolean poolable)`
`void` `setPrepareThreshold(int newThreshold)` Sets the reuse threshold for using server-prepared statements.
`void` `setQueryTimeout(int seconds)`
`void` `setQueryTimeoutMs(long millis)` Sets the queryTimeout limit.
`void` `setUseServerPrepare(boolean flag)` Turn on the use of prepared statements in the server (server side prepared statements are unrelated to jdbc PreparedStatements) As of build 302, this method is equivalent to `setPrepareThreshold(1)`.
`protected void` `transformQueriesAndParameters()`
`<T> T` `unwrap(Class<T> iface)`
`void` `updateStatementCancleState(com.amazon.redshift.jdbc.StatementCancelState oldState, com.amazon.redshift.jdbc.StatementCancelState newState)` Internal use only.
`protected boolean` `wantsHoldableResultSet()`
`protected boolean` `wantsScrollableResultSet()`

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

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Field Detail

#### batchStatements

    protected ArrayList<Query> batchStatements

#### batchParameters

    protected ArrayList<ParameterList> batchParameters

#### resultsettype

    protected final int resultsettype

#### concurrency

    protected final int concurrency

#### fetchdirection

    protected int fetchdirection

#### autoGeneratedKeys

    protected int autoGeneratedKeys

#### wantsGeneratedKeysOnce

    protected boolean wantsGeneratedKeysOnce

Does the caller of execute/executeUpdate want generated keys for this execution? This is set by Statement methods that have generated keys arguments and cleared after execution is complete.

#### wantsGeneratedKeysAlways

    public boolean wantsGeneratedKeysAlways

Was this PreparedStatement created to return generated keys for every execution? This is set at creation time and never cleared by execution.

#### connection

    protected final BaseConnection connection

#### warnings

    protected volatile com.amazon.redshift.jdbc.RedshiftWarningWrapper warnings

The warnings chain.

#### maxrows

    protected int maxrows

Maximum number of rows to return, 0 = unlimited.

#### fetchSize

    protected int fetchSize

Number of rows to get in a batch.

#### timeout

    protected long timeout

Timeout (in milliseconds) for a query.

#### replaceProcessingEnabled

    protected boolean replaceProcessingEnabled

#### result

    protected ResultWrapper result

The current results.

#### firstUnclosedResult

    protected volatile ResultWrapper firstUnclosedResult

The first unclosed result.

#### generatedKeys

    protected ResultWrapper generatedKeys

Results returned by a statement that wants generated keys.

#### mPrepareThreshold

    protected int mPrepareThreshold

#### maxFieldSize

    protected int maxFieldSize

### Method Detail

#### createResultSet

    public ResultSet createResultSet(Query originalQuery,
                                     Field[] fields,
                                     List<Tuple> tuples,
                                     ResultCursor cursor,
                                     RedshiftRowsBlockingQueue<Tuple> queueTuples,
                                     int[] rowCount,
                                     Thread ringBufferThread)
                              throws SQLException

Description copied from interface: `BaseStatement`
Create a resultset from data retrieved from the server.

Specified by:
  `createResultSet` in interface `BaseStatement`
Parameters:
  `originalQuery` - the query that generated this resultset; used when dealing with updateable resultsets
  `fields` - the column metadata for the resultset
  `tuples` - the resultset data
  `cursor` - the cursor to use to retrieve more data from the server; if null, no additional data is present.
  `queueTuples` - the actual data in a blocking queue. If this is set then tuples will be null.
  `rowCount` - number of rows fetched from the socket.
  `ringBufferThread` - a thread to fetch rows in the limited rows buffer.
Returns:
  the new ResultSet
Throws:
  `SQLException` - if something goes wrong

#### getRedshiftConnection

    public BaseConnection getRedshiftConnection()

#### getFetchingCursorName

    public String getFetchingCursorName()

#### getFetchSize

    public int getFetchSize()

Specified by:
  `getFetchSize` in interface `Statement`

#### wantsScrollableResultSet

    protected boolean wantsScrollableResultSet()

#### wantsHoldableResultSet

    protected boolean wantsHoldableResultSet()

#### updateStatementCancleState

    public void updateStatementCancleState(com.amazon.redshift.jdbc.StatementCancelState oldState,
                                           com.amazon.redshift.jdbc.StatementCancelState newState)

Internal use only.

Parameters:
  `oldState` - old state of the statement
  `newState` - new state of the statement

#### executeQuery

    public ResultSet executeQuery(String sql)
                           throws SQLException

Specified by:
  `executeQuery` in interface `Statement`
Throws:
  `SQLException`

#### getSingleResultSet

    protected ResultSet getSingleResultSet()
                                    throws SQLException

Throws:
  `SQLException`

#### executeUpdate

    public int executeUpdate(String sql)
                      throws SQLException

Specified by:
  `executeUpdate` in interface `Statement`
Throws:
  `SQLException`

#### checkNoResultUpdate

    protected final void checkNoResultUpdate()
                                      throws SQLException

Throws:
  `SQLException`

#### execute

    public boolean execute(String sql)
                    throws SQLException

Specified by:
  `execute` in interface `Statement`
Throws:
  `SQLException`

#### executeWithFlags

    public boolean executeWithFlags(String sql,
                                    int flags)
                             throws SQLException

Description copied from interface: `BaseStatement`
Execute a query, passing additional query flags.

Specified by:
  `executeWithFlags` in interface `BaseStatement`
Parameters:
  `sql` - the query to execute (JDBC-style query)
  `flags` - additional `QueryExecutor` flags for execution; these are bitwise-ORed into the default flags.
Returns:
  true if there is a result set
Throws:
  `SQLException` - if something goes wrong.

#### executeWithFlags

    public boolean executeWithFlags(CachedQuery simpleQuery,
                                    int flags)
                             throws SQLException

Description copied from interface: `BaseStatement`
Execute a query, passing additional query flags.

Specified by:
  `executeWithFlags` in interface `BaseStatement`
Parameters:
  `simpleQuery` - the query to execute (native to Redshift)
  `flags` - additional `QueryExecutor` flags for execution; these are bitwise-ORed into the default flags.
Returns:
  true if there is a result set
Throws:
  `SQLException` - if something goes wrong.

#### executeWithFlags

    public boolean executeWithFlags(int flags)
                             throws SQLException

Description copied from interface: `BaseStatement`
Execute a prepared query, passing additional query flags.

Specified by:
  `executeWithFlags` in interface `BaseStatement`
Parameters:
  `flags` - additional `QueryExecutor` flags for execution; these are bitwise-ORed into the default flags.
Returns:
  true if there is a result set
Throws:
  `SQLException` - if something goes wrong.

#### closeForNextExecution

    protected void closeForNextExecution()
                                  throws SQLException

Throws:
  `SQLException`

#### isOneShotQuery

    protected boolean isOneShotQuery(CachedQuery cachedQuery)

Returns true if query is unlikely to be reused.

Parameters:
  `cachedQuery` - to check (null if current query)
Returns:
  true if query is unlikely to be reused

#### execute

    protected final void execute(CachedQuery cachedQuery,
                                 ParameterList queryParameters,
                                 int flags)
                          throws SQLException

Throws:
  `SQLException`

#### setCursorName

    public void setCursorName(String name)
                       throws SQLException

Specified by:
  `setCursorName` in interface `Statement`
Throws:
  `SQLException`

#### getUpdateCount

    public int getUpdateCount()
                       throws SQLException

Specified by:
  `getUpdateCount` in interface `Statement`
Throws:
  `SQLException`

#### getMoreResults

    public boolean getMoreResults()
                           throws SQLException

Specified by:
  `getMoreResults` in interface `Statement`
Throws:
  `SQLException`

#### getMaxRows

    public int getMaxRows()
                   throws SQLException

Specified by:
  `getMaxRows` in interface `Statement`
Throws:
  `SQLException`

#### setMaxRows

    public void setMaxRows(int max)
                    throws SQLException

Specified by:
  `setMaxRows` in interface `Statement`
Throws:
  `SQLException`

#### setEscapeProcessing

    public void setEscapeProcessing(boolean enable)
                             throws SQLException

Specified by:
  `setEscapeProcessing` in interface `Statement`
Throws:
  `SQLException`

#### getQueryTimeout

    public int getQueryTimeout()
                        throws SQLException

Specified by:
  `getQueryTimeout` in interface `Statement`
Throws:
  `SQLException`

#### setQueryTimeout

    public void setQueryTimeout(int seconds)
                         throws SQLException

Specified by:
  `setQueryTimeout` in interface `Statement`
Throws:
  `SQLException`

#### getQueryTimeoutMs

    public long getQueryTimeoutMs()
                           throws SQLException

The queryTimeout limit is the number of milliseconds the driver will wait for a Statement to execute. If the limit is exceeded, a SQLException is thrown.

Returns:
  the current query timeout limit in milliseconds; 0 = unlimited
Throws:
  `SQLException` - if a database access error occurs

#### setQueryTimeoutMs

    public void setQueryTimeoutMs(long millis)
                           throws SQLException

Sets the queryTimeout limit.

Parameters:
  `millis` - - the new query timeout limit in milliseconds
Throws:
  `SQLException` - if a database access error occurs

#### addWarning

    public void addWarning(SQLWarning warn)

Either initializes new warning wrapper, or adds warning onto the chain.

Although warnings are expected to be added sequentially, the warnings chain may be cleared concurrently at any time via `clearWarnings()`, therefore it is possible that a warning added via this method is placed onto the end of the previous warning chain

Parameters:
  `warn` - warning to add

#### getWarnings

    public SQLWarning getWarnings()
                           throws SQLException

Specified by:
  `getWarnings` in interface `Statement`
Throws:
  `SQLException`

#### getMaxFieldSize

    public int getMaxFieldSize()
                        throws SQLException

Specified by:
  `getMaxFieldSize` in interface `Statement`
Throws:
  `SQLException`

#### setMaxFieldSize

    public void setMaxFieldSize(int max)
                         throws SQLException

Specified by:
  `setMaxFieldSize` in interface `Statement`
Throws:
  `SQLException`

#### clearWarnings

    public void clearWarnings()
                       throws SQLException

Clears the warning chain.

Note that while it is safe to clear warnings while the query is executing, warnings that are added between calls to `getWarnings()` and #clearWarnings() may be missed. Therefore you should hold a reference to the tail of the previous warning chain and verify if its `SQLWarning.getNextWarning()` value is holds any new value.

Specified by:
  `clearWarnings` in interface `Statement`
Throws:
  `SQLException`

#### getResultSet

    public ResultSet getResultSet()
                           throws SQLException

Specified by:
  `getResultSet` in interface `Statement`
Throws:
  `SQLException`

#### close

    public final void close()
                     throws SQLException

Note: even though `Statement` is automatically closed when it is garbage collected, it is better to close it explicitly to lower resource consumption.

Specified by:
  `close` in interface `AutoCloseable`
Specified by:
  `close` in interface `Statement`
Throws:
  `SQLException`

#### closeImpl

    protected void closeImpl()
                      throws SQLException

This is guaranteed to be called exactly once even in case of concurrent `close()` calls.

Throws:
  `SQLException` - in case of error

#### getLastOID

    public long getLastOID()
                    throws SQLException

Description copied from interface: `RedshiftStatement`
Returns the Last inserted/updated oid.

Specified by:
  `getLastOID` in interface `RedshiftStatement`
Returns:
  OID of last insert
Throws:
  `SQLException` - if something goes wrong

#### setPrepareThreshold

    public void setPrepareThreshold(int newThreshold)
                             throws SQLException

Description copied from interface: `RedshiftStatement`

Sets the reuse threshold for using server-prepared statements.

If `threshold` is a non-zero value N, the Nth and subsequent reuses of a PreparedStatement will use server-side prepare.

If `threshold` is zero, server-side prepare will not be used.

The reuse threshold is only used by PreparedStatement and CallableStatement objects; it is ignored for plain Statements.

Specified by:
  `setPrepareThreshold` in interface `RedshiftStatement`
Parameters:
  `newThreshold` - the new threshold for this statement
Throws:
  `SQLException` - if an exception occurs while changing the threshold

#### getPrepareThreshold

    public int getPrepareThreshold()

Description copied from interface: `RedshiftStatement`
Gets the server-side prepare reuse threshold in use for this statement.

Specified by:
  `getPrepareThreshold` in interface `RedshiftStatement`
Returns:
  the current threshold
See Also:
  `RedshiftStatement.setPrepareThreshold(int)`

#### setUseServerPrepare

    public void setUseServerPrepare(boolean flag)
                             throws SQLException

Description copied from interface: `RedshiftStatement`
Turn on the use of prepared statements in the server (server side prepared statements are unrelated to jdbc PreparedStatements) As of build 302, this method is equivalent to `setPrepareThreshold(1)`.

Specified by:
  `setUseServerPrepare` in interface `RedshiftStatement`
Parameters:
  `flag` - use server prepare
Throws:
  `SQLException` - if something goes wrong

#### isUseServerPrepare

    public boolean isUseServerPrepare()

Description copied from interface: `RedshiftStatement`
Checks if this statement will be executed as a server-prepared statement. A return value of `true` indicates that the next execution of the statement will be done as a server-prepared statement, assuming the underlying protocol supports it.

Specified by:
  `isUseServerPrepare` in interface `RedshiftStatement`
Returns:
  true if the next reuse of this statement will use a server-prepared statement

#### checkClosed

    protected void checkClosed()
                        throws SQLException

Throws:
  `SQLException`

#### addBatch

    public void addBatch(String sql)
                  throws SQLException

Specified by:
  `addBatch` in interface `Statement`
Throws:
  `SQLException`

#### clearBatch

    public void clearBatch()
                    throws SQLException

Specified by:
  `clearBatch` in interface `Statement`
Throws:
  `SQLException`

#### createBatchHandler

    protected BatchResultHandler createBatchHandler(Query[] queries,
                                                    ParameterList[] parameterLists)

#### executeBatch

    public int[] executeBatch()
                       throws SQLException

Specified by:
  `executeBatch` in interface `Statement`
Throws:
  `SQLException`

#### cancel

    public void cancel()
                throws SQLException

Specified by:
  `cancel` in interface `Statement`
Throws:
  `SQLException`

#### getConnection

    public Connection getConnection()
                             throws SQLException

Specified by:
  `getConnection` in interface `Statement`
Throws:
  `SQLException`

#### getFetchDirection

    public int getFetchDirection()
                          throws SQLException

Specified by:
  `getFetchDirection` in interface `Statement`
Throws:
  `SQLException`

#### getResultSetConcurrency

    public int getResultSetConcurrency()
                                throws SQLException

Specified by:
  `getResultSetConcurrency` in interface `Statement`
Throws:
  `SQLException`

#### getResultSetType

    public int getResultSetType()
                         throws SQLException

Specified by:
  `getResultSetType` in interface `Statement`
Throws:
  `SQLException`

#### setFetchDirection

    public void setFetchDirection(int direction)
                           throws SQLException

Specified by:
  `setFetchDirection` in interface `Statement`
Throws:
  `SQLException`

#### setFetchSize

    public void setFetchSize(int rows)
                      throws SQLException

Specified by:
  `setFetchSize` in interface `Statement`
Throws:
  `SQLException`

#### getForceBinaryTransfer

    protected boolean getForceBinaryTransfer()

#### getLargeUpdateCount

    public long getLargeUpdateCount()
                             throws SQLException

Specified by:
  `getLargeUpdateCount` in interface `Statement`
Throws:
  `SQLException`

#### setLargeMaxRows

    public void setLargeMaxRows(long max)
                         throws SQLException

Specified by:
  `setLargeMaxRows` in interface `Statement`
Throws:
  `SQLException`

#### getLargeMaxRows

    public long getLargeMaxRows()
                         throws SQLException

Specified by:
  `getLargeMaxRows` in interface `Statement`
Throws:
  `SQLException`

#### executeLargeBatch

    public long[] executeLargeBatch()
                             throws SQLException

Specified by:
  `executeLargeBatch` in interface `Statement`
Throws:
  `SQLException`

#### executeLargeUpdate

    public long executeLargeUpdate(String sql)
                            throws SQLException

Specified by:
  `executeLargeUpdate` in interface `Statement`
Throws:
  `SQLException`

#### executeLargeUpdate

    public long executeLargeUpdate(String sql,
                                   int autoGeneratedKeys)
                            throws SQLException

Specified by:
  `executeLargeUpdate` in interface `Statement`
Throws:
  `SQLException`

#### executeLargeUpdate

    public long executeLargeUpdate(String sql,
                                   int[] columnIndexes)
                            throws SQLException

Specified by:
  `executeLargeUpdate` in interface `Statement`
Throws:
  `SQLException`

#### executeLargeUpdate

    public long executeLargeUpdate(String sql,
                                   String[] columnNames)
                            throws SQLException

Specified by:
  `executeLargeUpdate` in interface `Statement`
Throws:
  `SQLException`

#### isClosed

    public boolean isClosed()
                     throws SQLException

Specified by:
  `isClosed` in interface `Statement`
Throws:
  `SQLException`

#### setPoolable

    public void setPoolable(boolean poolable)
                     throws SQLException

Specified by:
  `setPoolable` in interface `Statement`
Throws:
  `SQLException`

#### isPoolable

    public boolean isPoolable()
                       throws SQLException

Specified by:
  `isPoolable` in interface `Statement`
Throws:
  `SQLException`

#### isWrapperFor

    public boolean isWrapperFor(Class<?> iface)
                         throws SQLException

Specified by:
  `isWrapperFor` in interface `Wrapper`
Throws:
  `SQLException`

#### unwrap

    public <T> T unwrap(Class<T> iface)
                 throws SQLException

Specified by:
  `unwrap` in interface `Wrapper`
Throws:
  `SQLException`

#### closeOnCompletion

    public void closeOnCompletion()
                           throws SQLException

Specified by:
  `closeOnCompletion` in interface `Statement`
Throws:
  `SQLException`

#### isCloseOnCompletion

    public boolean isCloseOnCompletion()
                                throws SQLException

Specified by:
  `isCloseOnCompletion` in interface `Statement`
Throws:
  `SQLException`

#### checkCompletion

    protected void checkCompletion()
                            throws SQLException

Throws:
  `SQLException`

#### getMoreResults

    public boolean getMoreResults(int current)
                           throws SQLException

Specified by:
  `getMoreResults` in interface `Statement`
Throws:
  `SQLException`

#### getGeneratedKeys

    public ResultSet getGeneratedKeys()
                               throws SQLException

Specified by:
  `getGeneratedKeys` in interface `Statement`
Throws:
  `SQLException`

#### executeUpdate

    public int executeUpdate(String sql,
                             int autoGeneratedKeys)
                      throws SQLException

Specified by:
  `executeUpdate` in interface `Statement`
Throws:
  `SQLException`

#### executeUpdate

    public int executeUpdate(String sql,
                             int[] columnIndexes)
                      throws SQLException

Specified by:
  `executeUpdate` in interface `Statement`
Throws:
  `SQLException`

#### executeUpdate

    public int executeUpdate(String sql,
                             String[] columnNames)
                      throws SQLException

Specified by:
  `executeUpdate` in interface `Statement`
Throws:
  `SQLException`

#### execute

    public boolean execute(String sql,
                           int autoGeneratedKeys)
                    throws SQLException

Specified by:
  `execute` in interface `Statement`
Throws:
  `SQLException`

#### execute

    public boolean execute(String sql,
                           int[] columnIndexes)
                    throws SQLException

Specified by:
  `execute` in interface `Statement`
Throws:
  `SQLException`

#### execute

    public boolean execute(String sql,
                           String[] columnNames)
                    throws SQLException

Specified by:
  `execute` in interface `Statement`
Throws:
  `SQLException`

#### getResultSetHoldability

    public int getResultSetHoldability()
                                throws SQLException

Specified by:
  `getResultSetHoldability` in interface `Statement`
Throws:
  `SQLException`

#### createDriverResultSet

    public ResultSet createDriverResultSet(Field[] fields,
                                           List<Tuple> tuples)
                                    throws SQLException

Description copied from interface: `BaseStatement`
Create a synthetic resultset from data provided by the driver.

Specified by:
  `createDriverResultSet` in interface `BaseStatement`
Parameters:
  `fields` - the column metadata for the resultset
  `tuples` - the resultset data
Returns:
  the new ResultSet
Throws:
  `SQLException` - if something goes wrong

#### transformQueriesAndParameters

    protected void transformQueriesAndParameters()
                                          throws SQLException

Throws:
  `SQLException`