# 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 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

Modifier and Type
Method
Description
`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 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, getSocketIp, 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 Object

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

### Methods inherited from interface 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 Details

### 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.