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
`static ThreadPoolExecutor` `readScheduler`

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

`activeStreamingResult, autoIncrementIncrement, connected, currentHost, database, dataTypeMappingFlags, eofDeprecated, explicitClosed, hasWarnings, IS_MASTER_QUERY, lock, options, proxy, reader, readOnly, serverCapabilities, serverPrepareStatementCache, serverStatus, serverThreadId, SESSION_QUERY, socket, urlParser, writer`

### Constructor Summary

Constructors
Constructor and Description
`AbstractQueryProtocol(UrlParser urlParser, ReentrantLock lock)` Get a protocol instance.

### Method Summary

All Methods Instance Methods Concrete Methods
`ServerPrepareResult` `addPrepareInCache(String key, ServerPrepareResult serverPrepareResult)`
`void` `cancelCurrentQuery()` Cancels the current query - clones the current protocol and executes a query using the new connection.
`void` `closeExplicit()`
`void` `executeBatch(boolean mustExecuteOnMaster, Results results, List<String> queries)` Execute list of queries not rewritable.
`void` `executeBatchMulti(boolean mustExecuteOnMaster, Results results, ClientPrepareResult clientPrepareResult, List<ParameterHolder[]> parametersList)` Execute clientPrepareQuery batch.
`void` `executeBatchMultiple(boolean mustExecuteOnMaster, Results results, List<String> queries)` Execute list of queries.
`void` `executeBatchRewrite(boolean mustExecuteOnMaster, Results results, ClientPrepareResult prepareResult, List<ParameterHolder[]> parameterList, boolean rewriteValues)` Specific execution for batch rewrite that has specific query for memory.
`void` `executePreparedQuery(boolean mustExecuteOnMaster, ServerPrepareResult serverPrepareResult, Results results, ParameterHolder[] parameters)` Execute a query that is already prepared.
`void` `executeQuery(boolean mustExecuteOnMaster, Results results, ClientPrepareResult clientPrepareResult, ParameterHolder[] parameters)` Execute a unique clientPrepareQuery.
`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(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.
`long` `getMaxRows()`
`void` `getResult(Results results)`
`int` `getTimeout()` Returns the connection timeout in milliseconds.
`int` `getTransactionIsolationLevel()`
`SQLException` `handleIoException(IOException initialException)` Handle IoException (reconnect if Exception is due to having send too much data, making server close the connection.
`boolean` `inTransaction()`
`boolean` `ping()`
`ServerPrepareResult` `prepare(String sql, boolean executeOnMaster)` Prepare query on server side.
`ServerPrepareResult` `prepareAndExecute(boolean mustExecuteOnMaster, ServerPrepareResult serverPrepareResult, Results results, String sql, ParameterHolder[] parameters)` Execute Prepare if needed, and execute COM_STMT_EXECUTE queries in batch.
`ServerPrepareResult` `prepareAndExecutes(boolean mustExecuteOnMaster, ServerPrepareResult serverPrepareResult, Results results, String sql, List<ParameterHolder[]> parametersList)` Execute Prepare if needed, and execute COM_STMT_EXECUTE queries in batch.
`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)`
`SQLException` `readErrorPacket(Buffer buffer, Results results)` Read ERR_Packet.
`void` `readLocalInfilePacket(Buffer buffer, Results results)` Read Local_infile Packet.
`void` `readOkPacket(Buffer buffer, Results results)` Read OK_Packet.
`void` `readPacket(Results results)` Read server response packet.
`void` `readResultSet(Buffer buffer, Results results)` Read ResultSet Packet.
`void` `releasePrepareStatement(ServerPrepareResult serverPrepareResult)` Deallocate prepare statement if not used anymore.
`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` `setInternalMaxRows(long max)` Set max row retuen by a statement.
`void` `setLocalInfileInputStream(InputStream inputStream)`
`void` `setMaxRows(long max)`
`void` `setTimeout(int timeout)` Sets the connection timeout.
`void` `setTransactionIsolation(int level)` Set transaction isolation.

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

`changeSocketSoTimeout, changeSocketTcpNoDelay, checkIfMaster, close, close, connect, connectWithoutProxy, enabledSslCipherSuites, enabledSslProtocolSuites, getActiveStreamingResult, getDatabase, getDataTypeMappingFlags, getHost, getHostAddress, getLock, getMajorServerVersion, getMinorServerVersion, getOptions, getPassword, getPinGlobalTxToPhysicalConnection, getPort, getProxy, getReader, getReadonly, getServerData, getServerThreadId, getServerVersion, getTimeZone, getTraces, getUrlParser, getUsername, getWriter, hasMoreResults, hasWarnings, isClosed, isConnected, isEofDeprecated, isExplicitClosed, isMasterConnection, isServerMariaDb, mustBeMasterConnection, noBackslashEscapes, prepareStatementCache, readEofPacket, readPipelineCheckMaster, removeActiveStreamingResult, removeHasMoreResults, sendPipelineCheckMaster, sessionStateAware, setActiveStreamingResult, setHasWarnings, setHostAddress, setHostFailedWithoutProxy, setProxy, setReadonly, 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

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

### Field Detail

#### readScheduler

    public static ThreadPoolExecutor readScheduler

### Constructor Detail

#### AbstractQueryProtocol

    public AbstractQueryProtocol(UrlParser urlParser,
                                 ReentrantLock lock)

Get a protocol instance.

Parameters:
  `urlParser` - connection URL infos
  `lock` - the lock for thread synchronisation

### Method Detail

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

#### executeBatchMulti

    public void executeBatchMulti(boolean mustExecuteOnMaster,
                                  Results results,
                                  ClientPrepareResult clientPrepareResult,
                                  List<ParameterHolder[]> parametersList)
                           throws SQLException

Execute clientPrepareQuery batch.

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

#### executeBatch

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

Execute list of queries not rewritable.

Specified by:
  `executeBatch` in interface `Protocol`
Parameters:
  `mustExecuteOnMaster` - was intended to be launched on master connection
  `results` - result object
  `queries` - list of queries
Throws:
  `SQLException` - exception

#### 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 resultset 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 slave, can be execute temporary on master, but we keep this flag, so when a slave is connected back to relaunch this query on slave)

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.

#### executeBatchMultiple

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

Execute list of queries. This method is used when using text batch statement and using rewriting (allowMultiQueries || rewriteBatchedStatements). queries will be send to server according to max_allowed_packet size.

Specified by:
  `executeBatchMultiple` in interface `Protocol`
Parameters:
  `mustExecuteOnMaster` - was intended to be launched on master connection
  `results` - result object
  `queries` - list of queries
Throws:
  `SQLException` - exception

#### executeBatchRewrite

    public void executeBatchRewrite(boolean mustExecuteOnMaster,
                                    Results results,
                                    ClientPrepareResult prepareResult,
                                    List<ParameterHolder[]> parameterList,
                                    boolean rewriteValues)
                             throws SQLException

Specific execution for batch rewrite that has specific query for memory.

Specified by:
  `executeBatchRewrite` in interface `Protocol`
Parameters:
  `mustExecuteOnMaster` - was intended to be launched on master connection
  `results` - result
  `prepareResult` - prepareResult
  `parameterList` - parameters
  `rewriteValues` - is rewritable flag
Throws:
  `SQLException` - exception

#### prepareAndExecutes

    public ServerPrepareResult prepareAndExecutes(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:
  `prepareAndExecutes` 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:
  Prepare result
Throws:
  `SQLException` - if parameter error or connection error occur.

#### prepareAndExecute

    public ServerPrepareResult prepareAndExecute(boolean mustExecuteOnMaster,
                                                 ServerPrepareResult serverPrepareResult,
                                                 Results results,
                                                 String sql,
                                                 ParameterHolder[] parameters)
                                          throws SQLException

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

Specified by:
  `prepareAndExecute` 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
  `parameters` - parameters
Returns:
  Prepare result
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 preparestatement 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`

#### setCatalog

    public void setCatalog(String database)
                    throws SQLException

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

#### cancelCurrentQuery

    public void cancelCurrentQuery()
                            throws SQLException,
                                   IOException

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
  `IOException` - if Host is not responding

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

#### setInternalMaxRows

    public void setInternalMaxRows(long max)

Set max row retuen by a statement.

Specified by:
  `setInternalMaxRows` in interface `Protocol`
Parameters:
  `max` - row number max value

#### 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()
                   throws SocketException

Returns the connection timeout in milliseconds.

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

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

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

#### readPacket

    public void readPacket(Results results)
                    throws SQLException

Read server response packet.

Parameters:
  `results` - result object
Throws:
  `SQLException` - if sub-result connection fail
See Also:
  server response packets

#### readOkPacket

    public void readOkPacket(Buffer buffer,
                             Results results)
                      throws SQLException

Read OK_Packet.

Parameters:
  `buffer` - current buffer
  `results` - result object
Throws:
  `SQLException` - if sub-result connection fail
See Also:
  OK_Packet

#### getAutoIncrementIncrement

    public int getAutoIncrementIncrement()

Get current auto increment increment.

Specified by:
  `getAutoIncrementIncrement` in interface `Protocol`
Returns:
  auto increment increment.

#### readErrorPacket

    public SQLException readErrorPacket(Buffer buffer,
                                        Results results)

Read ERR_Packet.

Parameters:
  `buffer` - current buffer
  `results` - result object
Returns:
  SQLException if sub-result connection fail
See Also:
  ERR_Packet

#### readLocalInfilePacket

    public void readLocalInfilePacket(Buffer buffer,
                                      Results results)
                               throws SQLException

Read Local_infile Packet.

Parameters:
  `buffer` - current buffer
  `results` - result object
Throws:
  `SQLException` - if sub-result connection fail
See Also:
  local_infile packet

#### readResultSet

    public void readResultSet(Buffer buffer,
                              Results results)
                       throws SQLException

Read ResultSet Packet.

Parameters:
  `buffer` - current buffer
  `results` - result object
Throws:
  `SQLException` - if sub-result connection fail
See Also:
  resultSet packets

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

#### addPrepareInCache

    public ServerPrepareResult addPrepareInCache(String key,
                                                 ServerPrepareResult serverPrepareResult)

Specified by:
  `addPrepareInCache` 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(IOException 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`