Package org.mariadb.jdbc.internal.protocol

## Class AbstractQueryProtocol

- java.lang.Object
- - org.mariadb.jdbc.internal.protocol.AbstractConnectProtocol
  - - org.mariadb.jdbc.internal.protocol.AbstractQueryProtocol

All Implemented Interfaces:
  `Protocol`

Direct Known Subclasses:
  `MasterProtocol`

    public class AbstractQueryProtocol
    extends AbstractConnectProtocol
    implements Protocol

### Field Summary

### Fields inherited from class org.mariadb.jdbc.internal.protocol.AbstractConnectProtocol

`activeStreamingResult, autoIncrementIncrement, CHECK_GALERA_STATE_QUERY, connected, database, eofDeprecated, exceptionFactory, explicitClosed, galeraAllowedStates, hasWarnings, lock, options, proxy, reader, readOnly, serverCapabilities, serverPrepareStatementCache, serverStatus, serverThreadId, socket, socketTimeout, traceCache, urlParser, writer`

### Method Summary

All Methods Instance Methods Concrete Methods
`void` `cancelCurrentQuery()` Cancels the current query - clones the current protocol and executes a query using the new connection.
`void` `closeExplicit()`
`boolean` `executeBatchClient​(boolean mustExecuteOnMaster, Results results, ClientPrepareResult prepareResult, List<ParameterHolder[]> parametersList)` Execute clientPrepareQuery batch.
`boolean` `executeBatchServer​(boolean mustExecuteOnMaster, ServerPrepareResult serverPrepareResult, Results results, String sql, List<ParameterHolder[]> parametersList)` Execute Prepare if needed, and execute COM_STMT_EXECUTE queries in batch.
`void` `executeBatchStmt​(boolean mustExecuteOnMaster, Results results, List<String> queries)` Execute batch from Statement.executeBatch().
`void` `executePreparedQuery​(boolean mustExecuteOnMaster, ServerPrepareResult serverPrepareResult, Results results, ParameterHolder[] parameters)` Execute a query that is already prepared.
`void` `executeQuery​(boolean mustExecuteOnMaster, Results results, String sql)` Execute query directly to outputStream.
`void` `executeQuery​(boolean mustExecuteOnMaster, Results results, String sql, Charset charset)`
`void` `executeQuery​(boolean mustExecuteOnMaster, Results results, ClientPrepareResult clientPrepareResult, ParameterHolder[] parameters)` Execute a unique clientPrepareQuery.
`void` `executeQuery​(boolean mustExecuteOnMaster, Results results, ClientPrepareResult clientPrepareResult, ParameterHolder[] parameters, int queryTimeout)` Execute a unique clientPrepareQuery.
`void` `executeQuery​(String sql)` Execute internal query.
`boolean` `forceReleasePrepareStatement​(int statementId)` Force release of prepare statement that are not used.
`void` `forceReleaseWaitingPrepareStatement()` Force release of prepare statement that are not used.
`boolean` `getAutocommit()` Get current autocommit status.
`int` `getAutoIncrementIncrement()` Get current auto increment increment.
`String` `getCatalog()`
`long` `getMaxRows()`
`void` `getResult​(Results results)`
`int` `getTimeout()` Returns the connection timeout in milliseconds.
`int` `getTransactionIsolationLevel()`
`SQLException` `handleIoException​(Exception initialException)` Handle IoException (reconnect if Exception is due to having send too much data, making server close the connection.
`void` `interrupt()`
`boolean` `inTransaction()`
`boolean` `isInterrupted()`
`boolean` `isValid​(int timeout)` Check that connection is valid.
`boolean` `ping()`
`ServerPrepareResult` `prepare​(String sql, boolean executeOnMaster)` Prepare query on server side.
`void` `prolog​(long maxRows, boolean hasProxy, MariaDbConnection connection, MariaDbStatement statement)` Preparation before command.
`void` `prologProxy​(ServerPrepareResult serverPrepareResult, long maxRows, boolean hasProxy, MariaDbConnection connection, MariaDbStatement statement)`
`ServerPrepareResult` `putInCache​(String key, ServerPrepareResult serverPrepareResult)`
`void` `releasePrepareStatement​(ServerPrepareResult serverPrepareResult)` Deallocate prepare statement if not used anymore.
`void` `reset()` Reset connection state.
`void` `resetDatabase()`
`void` `resetStateAfterFailover​(long maxRows, int transactionIsolationLevel, String database, boolean autocommit)` Set current state after a failover.
`void` `rollback()` Rollback transaction.
`void` `setActiveFutureTask​(FutureTask activeFutureTask)`
`void` `setCatalog​(String database)`
`void` `setLocalInfileInputStream​(InputStream inputStream)`
`void` `setMaxRows​(long max)`
`void` `setReadonly​(boolean readOnly)` Puts this connection in read-only / read-write mode
`void` `setTimeout​(int timeout)` Sets the connection timeout.
`void` `setTransactionIsolation​(int level)` Set transaction isolation.
`void` `stopIfInterrupted()` Throw TimeoutException if timeout has been reached.

### Methods inherited from class org.mariadb.jdbc.internal.protocol.AbstractConnectProtocol

`abort, changeSocketSoTimeout, changeSocketTcpNoDelay, checkIfMaster, close, connect, connectWithoutProxy, destroySocket, getActiveStreamingResult, getDatabase, getHost, getHostAddress, getLock, getMajorServerVersion, getMinorServerVersion, getOptions, getPatchServerVersion, getPinGlobalTxToPhysicalConnection, getPort, getProxy, getReader, getReadonly, getServerThreadId, getServerVersion, getSocket, getTimeZone, getTraces, getUrlParser, getUsername, hasMoreResults, hasWarnings, isClosed, isConnected, isEofDeprecated, isExplicitClosed, isMasterConnection, isServerMariaDb, mustBeMasterConnection, noBackslashEscapes, prepareStatementCache, readEofPacket, readPipelineCheckMaster, removeActiveStreamingResult, removeHasMoreResults, sessionStateAware, setActiveStreamingResult, setHasWarnings, setHostAddress, setHostFailedWithoutProxy, setProxy, setServerStatus, shouldReconnectWithoutProxy, skip, skipEofPacket, versionGreaterOrEqual`

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

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

### Methods inherited from interface org.mariadb.jdbc.internal.protocol.Protocol

`abort, changeSocketSoTimeout, changeSocketTcpNoDelay, checkIfMaster, close, connect, connectWithoutProxy, getActiveStreamingResult, getDatabase, getHost, getHostAddress, getLock, getMajorServerVersion, getMinorServerVersion, getOptions, getPatchServerVersion, getPinGlobalTxToPhysicalConnection, getPort, getProxy, getReader, getReadonly, getServerThreadId, getServerVersion, getSocket, getTimeZone, getTraces, getUrlParser, getUsername, hasMoreResults, hasWarnings, isClosed, isConnected, isEofDeprecated, isExplicitClosed, isMasterConnection, isServerMariaDb, mustBeMasterConnection, noBackslashEscapes, prepareStatementCache, readEofPacket, removeActiveStreamingResult, removeHasMoreResults, sessionStateAware, setActiveStreamingResult, setHasWarnings, setHostAddress, setHostFailedWithoutProxy, setProxy, setServerStatus, shouldReconnectWithoutProxy, skip, skipEofPacket, versionGreaterOrEqual`

### Method Detail

#### reset

    public void reset()
               throws SQLException

Reset connection state.

1. Transaction will be rollback
2. transaction isolation will be reset
3. user variables will be removed
4. sessions variables will be reset to global values

Specified by:
  `reset` in interface `Protocol`
Throws:
  `SQLException` - if command failed

#### executeQuery

    public void executeQuery​(String sql)
                      throws SQLException

Execute internal query.

!! will not support multi values queries !!

Specified by:
  `executeQuery` in interface `Protocol`
Specified by:
  `executeQuery` in class `AbstractConnectProtocol`
Parameters:
  `sql` - sql
Throws:
  `SQLException` - in any exception occur

#### executeQuery

    public void executeQuery​(boolean mustExecuteOnMaster,
                             Results results,
                             String sql)
                      throws SQLException

Execute query directly to outputStream.

Specified by:
  `executeQuery` in interface `Protocol`
Parameters:
  `mustExecuteOnMaster` - was intended to be launched on master connection
  `results` - result
  `sql` - the query to executeInternal
Throws:
  `SQLException` - exception

#### executeQuery

    public void executeQuery​(boolean mustExecuteOnMaster,
                             Results results,
                             String sql,
                             Charset charset)
                      throws SQLException

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

#### executeQuery

    public void executeQuery​(boolean mustExecuteOnMaster,
                             Results results,
                             ClientPrepareResult clientPrepareResult,
                             ParameterHolder[] parameters)
                      throws SQLException

Execute a unique clientPrepareQuery.

Specified by:
  `executeQuery` in interface `Protocol`
Parameters:
  `mustExecuteOnMaster` - was intended to be launched on master connection
  `results` - results
  `clientPrepareResult` - clientPrepareResult
  `parameters` - parameters
Throws:
  `SQLException` - exception

#### executeQuery

    public void executeQuery​(boolean mustExecuteOnMaster,
                             Results results,
                             ClientPrepareResult clientPrepareResult,
                             ParameterHolder[] parameters,
                             int queryTimeout)
                      throws SQLException

Execute a unique clientPrepareQuery.

Specified by:
  `executeQuery` in interface `Protocol`
Parameters:
  `mustExecuteOnMaster` - was intended to be launched on master connection
  `results` - results
  `clientPrepareResult` - clientPrepareResult
  `parameters` - parameters
  `queryTimeout` - if timeout is set and must use max_statement_time
Throws:
  `SQLException` - exception

#### executeBatchClient

    public boolean executeBatchClient​(boolean mustExecuteOnMaster,
                                      Results results,
                                      ClientPrepareResult prepareResult,
                                      List<ParameterHolder[]> parametersList)
                               throws SQLException

Execute clientPrepareQuery batch.

Specified by:
  `executeBatchClient` in interface `Protocol`
Parameters:
  `mustExecuteOnMaster` - was intended to be launched on master connection
  `results` - results
  `prepareResult` - ClientPrepareResult
  `parametersList` - List of parameters
Throws:
  `SQLException` - exception

#### executeBatchStmt

    public void executeBatchStmt​(boolean mustExecuteOnMaster,
                                 Results results,
                                 List<String> queries)
                          throws SQLException

Execute batch from Statement.executeBatch().

Specified by:
  `executeBatchStmt` in interface `Protocol`
Parameters:
  `mustExecuteOnMaster` - was intended to be launched on master connection
  `results` - results
  `queries` - queries
Throws:
  `SQLException` - if any exception occur

#### prepare

    public ServerPrepareResult prepare​(String sql,
                                       boolean executeOnMaster)
                                throws SQLException

Prepare query on server side. Will permit to know the parameter number of the query, and permit to send only the data on next results.

For failover, two additional information are in the result-set object : - current connection : Since server maintain a state of this prepare statement, all query will be executed on this particular connection. - executeOnMaster : state of current connection when creating this prepareStatement (if was on master, will only be executed on master. If was on a replica, can be execute temporary on master, but we keep this flag, so when a replica is connected back to relaunch this query on replica)

Specified by:
  `prepare` in interface `Protocol`
Parameters:
  `sql` - the query
  `executeOnMaster` - state of current connection when creating this prepareStatement
Returns:
  a ServerPrepareResult object that contain prepare result information.
Throws:
  `SQLException` - if any error occur on connection.

#### executeBatchServer

    public boolean executeBatchServer​(boolean mustExecuteOnMaster,
                                      ServerPrepareResult serverPrepareResult,
                                      Results results,
                                      String sql,
                                      List<ParameterHolder[]> parametersList)
                               throws SQLException

Execute Prepare if needed, and execute COM_STMT_EXECUTE queries in batch.

Specified by:
  `executeBatchServer` in interface `Protocol`
Parameters:
  `mustExecuteOnMaster` - must normally be executed on master connection
  `serverPrepareResult` - prepare result. can be null if not prepared.
  `results` - execution results
  `sql` - sql query if needed to be prepared
  `parametersList` - parameter list
Returns:
  executed
Throws:
  `SQLException` - if parameter error or connection error occur.

#### executePreparedQuery

    public void executePreparedQuery​(boolean mustExecuteOnMaster,
                                     ServerPrepareResult serverPrepareResult,
                                     Results results,
                                     ParameterHolder[] parameters)
                              throws SQLException

Execute a query that is already prepared.

Specified by:
  `executePreparedQuery` in interface `Protocol`
Parameters:
  `mustExecuteOnMaster` - must execute on master
  `serverPrepareResult` - prepare result
  `results` - execution result
  `parameters` - parameters
Throws:
  `SQLException` - exception

#### rollback

    public void rollback()
                  throws SQLException

Rollback transaction.

Specified by:
  `rollback` in interface `Protocol`
Throws:
  `SQLException`

#### forceReleasePrepareStatement

    public boolean forceReleasePrepareStatement​(int statementId)
                                         throws SQLException

Force release of prepare statement that are not used. This method will be call when adding a new prepare statement in cache, so the packet can be send to server without problem.

Specified by:
  `forceReleasePrepareStatement` in interface `Protocol`
Parameters:
  `statementId` - prepared statement Id to remove.
Returns:
  true if successfully released
Throws:
  `SQLException` - if connection exception.

#### forceReleaseWaitingPrepareStatement

    public void forceReleaseWaitingPrepareStatement()
                                             throws SQLException

Force release of prepare statement that are not used. This permit to deallocate a statement that cannot be release due to multi-thread use.

Specified by:
  `forceReleaseWaitingPrepareStatement` in interface `Protocol`
Throws:
  `SQLException` - if connection occur

#### ping

    public boolean ping()
                 throws SQLException

Specified by:
  `ping` in interface `Protocol`
Throws:
  `SQLException`

#### isValid

    public boolean isValid​(int timeout)
                    throws SQLException

Check that connection is valid. !! careful, timeout is in milliseconds, connection.isValid(timeout) is in seconds !!

Specified by:
  `isValid` in interface `Protocol`
Parameters:
  `timeout` - timeout in milliseconds
Returns:
  true is valid
Throws:
  `SQLException` - if any error occur

#### getCatalog

    public String getCatalog()
                      throws SQLException

Specified by:
  `getCatalog` in interface `Protocol`
Throws:
  `SQLException`

#### setCatalog

    public void setCatalog​(String database)
                    throws SQLException

Specified by:
  `setCatalog` in interface `Protocol`
Throws:
  `SQLException`

#### resetDatabase

    public void resetDatabase()
                       throws SQLException

Specified by:
  `resetDatabase` in interface `Protocol`
Throws:
  `SQLException`

#### cancelCurrentQuery

    public void cancelCurrentQuery()
                            throws SQLException

Cancels the current query - clones the current protocol and executes a query using the new connection.

Specified by:
  `cancelCurrentQuery` in interface `Protocol`
Throws:
  `SQLException` - never thrown

#### getAutocommit

    public boolean getAutocommit()

Get current autocommit status.

Specified by:
  `getAutocommit` in interface `Protocol`
Returns:
  autocommit status

#### inTransaction

    public boolean inTransaction()

Specified by:
  `inTransaction` in interface `Protocol`

#### closeExplicit

    public void closeExplicit()

Specified by:
  `closeExplicit` in interface `Protocol`

#### releasePrepareStatement

    public void releasePrepareStatement​(ServerPrepareResult serverPrepareResult)
                                 throws SQLException

Deallocate prepare statement if not used anymore.

Specified by:
  `releasePrepareStatement` in interface `Protocol`
Parameters:
  `serverPrepareResult` - allocation result
Throws:
  `SQLException` - if de-allocation failed.

#### getMaxRows

    public long getMaxRows()

Specified by:
  `getMaxRows` in interface `Protocol`

#### setMaxRows

    public void setMaxRows​(long max)
                    throws SQLException

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

#### setLocalInfileInputStream

    public void setLocalInfileInputStream​(InputStream inputStream)

Specified by:
  `setLocalInfileInputStream` in interface `Protocol`

#### getTimeout

    public int getTimeout()

Returns the connection timeout in milliseconds.

Specified by:
  `getTimeout` in interface `Protocol`
Returns:
  the connection timeout in milliseconds.

#### setTimeout

    public void setTimeout​(int timeout)
                    throws SocketException

Sets the connection timeout.

Specified by:
  `setTimeout` in interface `Protocol`
Parameters:
  `timeout` - the timeout, in milliseconds
Throws:
  `SocketException` - if there is an error in the underlying protocol, such as a TCP error.

#### setReadonly

    public void setReadonly​(boolean readOnly)
                     throws SQLException

Puts this connection in read-only / read-write mode

Specified by:
  `setReadonly` in interface `Protocol`
Parameters:
  `readOnly` - true enables read-only mode; false disables it
Throws:
  `SQLException` - If socket error.

#### setTransactionIsolation

    public void setTransactionIsolation​(int level)
                                 throws SQLException

Set transaction isolation.

Specified by:
  `setTransactionIsolation` in interface `Protocol`
Parameters:
  `level` - transaction level.
Throws:
  `SQLException` - if transaction level is unknown

#### getTransactionIsolationLevel

    public int getTransactionIsolationLevel()

Specified by:
  `getTransactionIsolationLevel` in interface `Protocol`

#### getResult

    public void getResult​(Results results)
                   throws SQLException

Specified by:
  `getResult` in interface `Protocol`
Throws:
  `SQLException`

#### getAutoIncrementIncrement

    public int getAutoIncrementIncrement()
                                  throws SQLException

Get current auto increment increment. *** no lock needed ****

Specified by:
  `getAutoIncrementIncrement` in interface `Protocol`
Returns:
  auto increment increment.
Throws:
  `SQLException` - if cannot retrieve auto increment value

#### prologProxy

    public void prologProxy​(ServerPrepareResult serverPrepareResult,
                            long maxRows,
                            boolean hasProxy,
                            MariaDbConnection connection,
                            MariaDbStatement statement)
                     throws SQLException

Specified by:
  `prologProxy` in interface `Protocol`
Throws:
  `SQLException`

#### prolog

    public void prolog​(long maxRows,
                       boolean hasProxy,
                       MariaDbConnection connection,
                       MariaDbStatement statement)
                throws SQLException

Preparation before command.

Specified by:
  `prolog` in interface `Protocol`
Parameters:
  `maxRows` - query max rows
  `hasProxy` - has proxy
  `connection` - current connection
  `statement` - current statement
Throws:
  `SQLException` - if any error occur.

#### putInCache

    public ServerPrepareResult putInCache​(String key,
                                          ServerPrepareResult serverPrepareResult)

Specified by:
  `putInCache` in interface `Protocol`

#### resetStateAfterFailover

    public void resetStateAfterFailover​(long maxRows,
                                        int transactionIsolationLevel,
                                        String database,
                                        boolean autocommit)
                                 throws SQLException

Set current state after a failover.

Specified by:
  `resetStateAfterFailover` in interface `Protocol`
Parameters:
  `maxRows` - current Max rows
  `transactionIsolationLevel` - current transactionIsolationLevel
  `database` - current database
  `autocommit` - current autocommit state
Throws:
  `SQLException` - if any error occur.

#### handleIoException

    public SQLException handleIoException​(Exception initialException)

Handle IoException (reconnect if Exception is due to having send too much data, making server close the connection.

There is 3 kind of IOException :

1. MaxAllowedPacketException : without need of reconnect : thrown when driver don't send packet that would have been too big then error is not a CONNECTION_EXCEPTION
2. packets size is greater than max_allowed_packet (can be checked with writer.isAllowedCmdLength()). Need to reconnect
3. unknown IO error throw a CONNECTION_EXCEPTION

Specified by:
  `handleIoException` in interface `Protocol`
Parameters:
  `initialException` - initial Io error
Returns:
  the resulting error to return to client.

#### setActiveFutureTask

    public void setActiveFutureTask​(FutureTask activeFutureTask)

Specified by:
  `setActiveFutureTask` in interface `Protocol`

#### interrupt

    public void interrupt()

Specified by:
  `interrupt` in interface `Protocol`

#### isInterrupted

    public boolean isInterrupted()

Specified by:
  `isInterrupted` in interface `Protocol`

#### stopIfInterrupted

    public void stopIfInterrupted()
                           throws SQLTimeoutException

Throw TimeoutException if timeout has been reached.

Specified by:
  `stopIfInterrupted` in interface `Protocol`
Throws:
  `SQLTimeoutException` - to indicate timeout exception.