ServerPreparedStatement
Date: 2018-05-01

com.mysql.jdbc

## Class ServerPreparedStatement

- java.lang.Object
- - com.mysql.jdbc.StatementImpl
  - - com.mysql.jdbc.PreparedStatement
    - - com.mysql.jdbc.ServerPreparedStatement

- All Implemented Interfaces:
    Wrapper, java.lang.AutoCloseable, java.sql.PreparedStatement, java.sql.Statement
  Direct Known Subclasses:
    JDBC4ServerPreparedStatement

      public class ServerPreparedStatement
      extends PreparedStatement

  JDBC Interface for MySQL-4.1 and newer server-side PreparedStatements.

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `ServerPreparedStatement.BatchedBindValues`
    `static class` | `ServerPreparedStatement.BindValue`

    - ### Nested classes/interfaces inherited from class com.mysql.jdbc.PreparedStatement

      `PreparedStatement.AppendingBatchVisitor, PreparedStatement.BatchParams, PreparedStatement.BatchVisitor, PreparedStatement.EmulatedPreparedStatementBindings, PreparedStatement.EndPoint, PreparedStatement.ParseInfo`

    - ### Nested classes/interfaces inherited from class com.mysql.jdbc.StatementImpl

      `StatementImpl.CancelTask`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected static int` | `BLOB_STREAM_READ_BUF_SIZE`
    `protected boolean` | `isCached`

    - ### Fields inherited from class com.mysql.jdbc.PreparedStatement

      `batchCommandIndex, batchedValuesClause, batchHasPlainStatements, firstCharOfStmt, isLoadDataQuery, isNull, numberOfExecutions, originalSql, parameterCount, parameterMetaData, parameterTypes, parseInfo, rewrittenBatchSize, serverSupportsFracSecs, useTrueBoolean, usingAnsiMode`

    - ### Fields inherited from class com.mysql.jdbc.StatementImpl

      `batchedArgs, batchedGeneratedKeys, cancelTimeoutMutex, charConverter, charEncoding, clearWarningsCalled, connection, connectionId, continueBatchOnError, currentCatalog, doEscapeProcessing, eventSink, generatedKeysResults, holdResultsOpenOverClose, isClosed, lastInsertId, lastQueryIsOnDupKeyUpdate, maxFieldSize, maxRows, ON_DUPLICATE_KEY_UPDATE_CLAUSE, openResults, pedantic, PING_MARKER, pingTarget, pointOfOrigin, profileSQL, results, resultSetConcurrency, resultSetType, retrieveGeneratedKeys, sendFractionalSeconds, statementCounter, statementExecuting, statementId, timeoutInMillis, updateCount, useLegacyDatetimeCode, USES_VARIABLES_FALSE, USES_VARIABLES_TRUE, USES_VARIABLES_UNKNOWN, useUsageAdvisor, version5013OrNewer, warningChain, wasCancelled, wasCancelledByTimeout`

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

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `ServerPreparedStatement(MySQLConnection conn, java.lang.String sql, java.lang.String catalog, int resultSetType, int resultSetConcurrency)` Creates a new ServerPreparedStatement object.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addBatch()` JDBC 2.0 Add a set of parameters to the batch.
    `java.lang.String` | `asSql(boolean quoteStreamsAndUnknowns)`
    `boolean` | `canRewriteAsMultiValueInsertAtSqlLevel()`
    `boolean` | `canRewriteAsMultivalueInsertStatement()`
    `protected MySQLConnection` | `checkClosed()` Checks if closed() has been called, and throws an exception if so
    `void` | `clearParameters()` In general, parameter values remain in force for repeated used of a Statement.
    `void` | `close()` In many cases, it is desirable to immediately release a Statement's database and JDBC resources instead of waiting for this to happen when it is automatically closed.
    `protected long[]` | `computeMaxParameterSetSizeAndBatchSize(int numBatchedArgs)` Computes the maximum parameter set size, and entire batch size given the number of arguments in the batch.
    `protected boolean` | `containsOnDuplicateKeyUpdateInSQL()`
    `protected long[]` | `executeBatchSerially(int batchTimeout)` Executes the current batch of statements by executing them one-by-one.
    `protected ResultSetInternalMethods` | `executeInternal(int maxRowsToRetrieve, Buffer sendPacket, boolean createStreamingResultSet, boolean queryIsSelectOnly, Field[] metadataFromCache, boolean isBatch)` Actually execute the prepared statement.
    `protected Buffer` | `fillSendPacket()` Creates the packet that contains the query to be sent to the server.
    `protected Buffer` | `fillSendPacket(byte[][] batchedParameterStrings, java.io.InputStream[] batchedParameterStreams, boolean[] batchedIsStream, int[] batchedStreamLengths)` Creates the packet that contains the query to be sent to the server.
    `protected ServerPreparedStatement.BindValue` | `getBinding(int parameterIndex, boolean forLongData)` Returns the structure representing the value that (can be)/(is) bound at the given parameter index.
    `(package private) byte[]` | `getBytes(int parameterIndex)`
    `protected static ServerPreparedStatement` | `getInstance(MySQLConnection conn, java.lang.String sql, java.lang.String catalog, int resultSetType, int resultSetConcurrency)` Creates a prepared statement instance -- We need to provide factory-style methods so we can support both JDBC3 (and older) and JDBC4 runtimes, otherwise the class verifier complains when it tries to load JDBC4-only interface classes that are present in JDBC4 method signatures.
    `protected int` | `getLocationOfOnDuplicateKeyUpdate()`
    `java.sql.ResultSetMetaData` | `getMetaData()` The number, types and properties of a ResultSet's columns are provided by the getMetaData method.
    `ServerPreparedStatement.BindValue[]` | `getParameterBindValues()` Return current bind values for use by Statement Interceptors.
    `java.sql.ParameterMetaData` | `getParameterMetaData()`
    `protected long` | `getServerStatementId()`
    `(package private) boolean` | `isNull(int paramIndex)`
    `protected boolean` | `isOnDuplicateKeyUpdate()`
    `protected PreparedStatement` | `prepareBatchedInsertSQL(MySQLConnection localConn, int numBatches)` Returns a prepared statement for the number of batched parameters, used when re-writing batch INSERTs.
    `protected void` | `realClose(boolean calledExplicitly, boolean closeOpenResults)` Closes this connection and frees all resources.
    `protected void` | `rePrepare()` Used by Connection when auto-reconnecting to retrieve 'lost' prepared statements.
    `void` | `setArray(int i, java.sql.Array x)` JDBC 2.0 Set an Array parameter.
    `void` | `setAsciiStream(int parameterIndex, java.io.InputStream x, int length)` When a very large ASCII value is input to a LONGVARCHAR parameter, it may be more practical to send it via a java.io.InputStream.
    `void` | `setBigDecimal(int parameterIndex, java.math.BigDecimal x)` Set a parameter to a java.math.BigDecimal value.
    `void` | `setBinaryStream(int parameterIndex, java.io.InputStream x, int length)` When a very large binary value is input to a LONGVARBINARY parameter, it may be more practical to send it via a java.io.InputStream.
    `void` | `setBlob(int parameterIndex, java.sql.Blob x)` JDBC 2.0 Set a BLOB parameter.
    `void` | `setBoolean(int parameterIndex, boolean x)` Set a parameter to a Java boolean value.
    `void` | `setByte(int parameterIndex, byte x)` Set a parameter to a Java byte value.
    `void` | `setBytes(int parameterIndex, byte[] x)` Set a parameter to a Java array of bytes.
    `void` | `setCharacterStream(int parameterIndex, java.io.Reader reader, int length)` JDBC 2.0 When a very large UNICODE value is input to a LONGVARCHAR parameter, it may be more practical to send it via a java.io.Reader.
    `void` | `setClob(int parameterIndex, java.sql.Clob x)` JDBC 2.0 Set a CLOB parameter.
    `protected void` | `setClosed(boolean flag)`
    `void` | `setDate(int parameterIndex, java.sql.Date x)` Set a parameter to a java.sql.Date value.
    `void` | `setDate(int parameterIndex, java.sql.Date x, java.util.Calendar cal)` Set a parameter to a java.sql.Date value.
    `void` | `setDouble(int parameterIndex, double x)` Set a parameter to a Java double value.
    `void` | `setFloat(int parameterIndex, float x)` Set a parameter to a Java float value.
    `void` | `setInt(int parameterIndex, int x)` Set a parameter to a Java int value.
    `void` | `setLong(int parameterIndex, long x)` Set a parameter to a Java long value.
    `void` | `setNull(int parameterIndex, int sqlType)` Set a parameter to SQL NULL Note: You must specify the parameters SQL type (although MySQL ignores it)
    `void` | `setNull(int parameterIndex, int sqlType, java.lang.String typeName)` Set a parameter to SQL NULL.
    `protected int` | `setOneBatchedParameterSet(java.sql.PreparedStatement batchedStatement, int batchedParamIndex, java.lang.Object paramSet)`
    `void` | `setRef(int i, java.sql.Ref x)` JDBC 2.0 Set a REF(<structured-type>) parameter.
    `void` | `setShort(int parameterIndex, short x)` Set a parameter to a Java short value.
    `void` | `setString(int parameterIndex, java.lang.String x)` Set a parameter to a Java String value.
    `void` | `setTime(int parameterIndex, java.sql.Time x)` Set a parameter to a java.sql.Time value.
    `void` | `setTime(int parameterIndex, java.sql.Time x, java.util.Calendar cal)` Set a parameter to a java.sql.Time value.
    `void` | `setTimestamp(int parameterIndex, java.sql.Timestamp x)` Set a parameter to a java.sql.Timestamp value.
    `void` | `setTimestamp(int parameterIndex, java.sql.Timestamp x, java.util.Calendar cal)` Set a parameter to a java.sql.Timestamp value.
    `protected void` | `setType(ServerPreparedStatement.BindValue oldValue, int bufferType)`
    `void` | `setUnicodeStream(int parameterIndex, java.io.InputStream x, int length)` Deprecated.
    `void` | `setURL(int parameterIndex, java.net.URL x)`
    `java.lang.String` | `toString()` Returns this PreparedStatement represented as a string.

    - ### Methods inherited from class com.mysql.jdbc.PreparedStatement

      `addBatch, asSql, canRewrite, checkBounds, checkReadOnlySafeStatement, clearBatch, computeBatchSize, detectFractionalSecondsSupport, execute, executeBatchedInserts, executeBatchInternal, executeLargeUpdate, executePreparedBatchAsMultiStatement, executeQuery, executeUpdate, executeUpdateInternal, executeUpdateInternal, getBytesRepresentation, getBytesRepresentationForBatch, getDateTime, getInstance, getInstance, getInstance, getNonRewrittenSql, getParameterBindings, getParameterIndexOffset, getParseInfo, getPreparedSql, getRewrittenBatchSize, getUpdateCount, getValuesClause, isSelectQuery, readFully, setAsciiStream, setAsciiStream, setBinaryStream, setBinaryStream, setBlob, setBlob, setBytes, setBytesNoEscape, setBytesNoEscapeNoQuotes, setCharacterStream, setCharacterStream, setClob, setClob, setInternal, setInternal, setNCharacterStream, setNCharacterStream, setNClob, setNClob, setNString, setObject, setObject, setObject, setRetrieveGeneratedKeys`

    - ### Methods inherited from class com.mysql.jdbc.StatementImpl

      `cancel, checkForDml, checkNullOrEmptyQuery, clearWarnings, closeAllOpenResults, closeOnCompletion, containsOnDuplicateKeyInString, createStreamingResultSet, disableStreamingResults, doPingInstead, enableStreamingResults, execute, execute, execute, execute, executeBatch, executeLargeBatch, executeLargeUpdate, executeLargeUpdate, executeLargeUpdate, executeLargeUpdate, executeQuery, executeSimpleNonQuery, executeUpdate, executeUpdate, executeUpdate, executeUpdate, executeUpdateInternal, findStartOfStatement, generatePingResultSet, getBatchedArgs, getBatchedGeneratedKeys, getBatchedGeneratedKeys, getCalendarInstanceForSessionOrNew, getConnection, getExceptionInterceptor, getFetchDirection, getFetchSize, getGeneratedKeys, getGeneratedKeysInternal, getGeneratedKeysInternal, getId, getLargeMaxRows, getLargeUpdateCount, getLastInsertID, getLocalInfileInputStream, getLongUpdateCount, getMaxFieldSize, getMaxRows, getMoreResults, getMoreResults, getOnDuplicateKeyLocation, getOpenResultSetCount, getQueryTimeout, getResultSet, getResultSetConcurrency, getResultSetHoldability, getResultSetInternal, getResultSetType, getWarnings, handleExceptionForBatch, hasDeadlockOrTimeoutRolledBackTx, implicitlyCloseAllOpenResults, isClosed, isCloseOnCompletion, isPoolable, isWrapperFor, processMultiCountsAndKeys, removeOpenResultSet, resetCancelledState, setCursorName, setEscapeProcessing, setFetchDirection, setFetchSize, setHoldResultsOpenOverClose, setLargeMaxRows, setLocalInfileInputStream, setMaxFieldSize, setMaxRows, setPingTarget, setPoolable, setQueryTimeout, setResultSetConcurrency, setResultSetType, setupStreamingTimeout, statementBegins, unwrap`

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

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

    - ### Methods inherited from interface java.sql.PreparedStatement

      `setNClob, setRowId, setSQLXML`

    - ### Methods inherited from interface java.sql.Statement

      `cancel, clearWarnings, closeOnCompletion, execute, execute, execute, execute, executeBatch, executeQuery, executeUpdate, executeUpdate, executeUpdate, executeUpdate, getConnection, getFetchDirection, getFetchSize, getGeneratedKeys, getMaxFieldSize, getMaxRows, getMoreResults, getMoreResults, getQueryTimeout, getResultSet, getResultSetConcurrency, getResultSetHoldability, getResultSetType, getWarnings, isClosed, isCloseOnCompletion, isPoolable, setCursorName, setEscapeProcessing, setFetchDirection, setFetchSize, setMaxFieldSize, setMaxRows, setPoolable, setQueryTimeout`

    - ### Methods inherited from interface java.sql.Wrapper

      `isWrapperFor, unwrap`

- - ### Field Detail

    - #### BLOB_STREAM_READ_BUF_SIZE

          protected static final int BLOB_STREAM_READ_BUF_SIZE

      See Also:
        Constant Field Values

    - #### isCached

          protected boolean isCached

  - ### Constructor Detail

    - #### ServerPreparedStatement

          protected ServerPreparedStatement(MySQLConnection conn,
                                 java.lang.String sql,
                                 java.lang.String catalog,
                                 int resultSetType,
                                 int resultSetConcurrency)
                                     throws java.sql.SQLException

      Creates a new ServerPreparedStatement object.
      Parameters:
        `conn` - the connection creating us.
        `sql` - the SQL containing the statement to prepare.
        `catalog` - the catalog in use when we were created.
      Throws:
        `java.sql.SQLException` - If an error occurs

  - ### Method Detail

    - #### getInstance

          protected static ServerPreparedStatement getInstance(MySQLConnection conn,
                                            java.lang.String sql,
                                            java.lang.String catalog,
                                            int resultSetType,
                                            int resultSetConcurrency)
                                                        throws java.sql.SQLException

      Creates a prepared statement instance -- We need to provide factory-style methods so we can support both JDBC3 (and older) and JDBC4 runtimes, otherwise the class verifier complains when it tries to load JDBC4-only interface classes that are present in JDBC4 method signatures.
      Throws:
        `java.sql.SQLException`

    - #### addBatch

          public void addBatch()
                        throws java.sql.SQLException

      JDBC 2.0 Add a set of parameters to the batch.
      Specified by:
        `addBatch` in interface `java.sql.PreparedStatement`
      Overrides:
        `addBatch` in class `PreparedStatement`
      Throws:
        `java.sql.SQLException` - if a database-access error occurs.
      See Also:
        `StatementImpl.addBatch(java.lang.String)`

    - #### asSql

          public java.lang.String asSql(boolean quoteStreamsAndUnknowns)
                                 throws java.sql.SQLException

      Overrides:
        `asSql` in class `PreparedStatement`
      Throws:
        `java.sql.SQLException`

    - #### checkClosed

          protected MySQLConnection checkClosed()
                                         throws java.sql.SQLException

      Description copied from class: `StatementImpl`
      Checks if closed() has been called, and throws an exception if so
      Overrides:
        `checkClosed` in class `StatementImpl`
      Throws:
        `java.sql.SQLException` - if this statement has been closed

    - #### clearParameters

          public void clearParameters()
                               throws java.sql.SQLException

      Description copied from class: `PreparedStatement`
      In general, parameter values remain in force for repeated used of a Statement. Setting a parameter value automatically clears its previous value. However, in some cases, it is useful to immediately release the resources used by the current parameter values; this can be done by calling clearParameters
      Specified by:
        `clearParameters` in interface `java.sql.PreparedStatement`
      Overrides:
        `clearParameters` in class `PreparedStatement`
      Throws:
        `java.sql.SQLException` - if a database access error occurs
      See Also:
        `PreparedStatement.clearParameters()`

    - #### setClosed

          protected void setClosed(boolean flag)

    - #### close

          public void close()
                     throws java.sql.SQLException

      Description copied from class: `StatementImpl`
      In many cases, it is desirable to immediately release a Statement's database and JDBC resources instead of waiting for this to happen when it is automatically closed. The close method provides this immediate release.

      Note: A Statement is automatically closed when it is garbage collected. When a Statement is closed, its current ResultSet, if one exists, is also closed.

      Specified by:
        `close` in interface `java.lang.AutoCloseable`
      Specified by:
        `close` in interface `java.sql.Statement`
      Overrides:
        `close` in class `StatementImpl`
      Throws:
        `java.sql.SQLException` - if a database access error occurs
      See Also:
        `Statement.close()`

    - #### executeBatchSerially

          protected long[] executeBatchSerially(int batchTimeout)
                                         throws java.sql.SQLException

      Description copied from class: `PreparedStatement`
      Executes the current batch of statements by executing them one-by-one.
      Overrides:
        `executeBatchSerially` in class `PreparedStatement`
      Returns:
        a list of update counts
      Throws:
        `java.sql.SQLException` - if an error occurs

    - #### executeInternal

          protected ResultSetInternalMethods executeInternal(int maxRowsToRetrieve,
                                                 Buffer sendPacket,
                                                 boolean createStreamingResultSet,
                                                 boolean queryIsSelectOnly,
                                                 Field[] metadataFromCache,
                                                 boolean isBatch)
                                                      throws java.sql.SQLException

      Description copied from class: `PreparedStatement`
      Actually execute the prepared statement. This is here so server-side PreparedStatements can re-use most of the code from this class.
      Overrides:
        `executeInternal` in class `PreparedStatement`
      Parameters:
        `maxRowsToRetrieve` - the max number of rows to return
        `sendPacket` - the packet to send
        `createStreamingResultSet` - should a 'streaming' result set be created?
        `queryIsSelectOnly` - is this query doing a SELECT?
      Returns:
        the results as a ResultSet
      Throws:
        `java.sql.SQLException` - if an error occurs.
      See Also:
        `com.mysql.jdbc.PreparedStatement#executeInternal(int, com.mysql.jdbc.Buffer, boolean, boolean)`

    - #### fillSendPacket

          protected Buffer fillSendPacket()
                                   throws java.sql.SQLException

      Description copied from class: `PreparedStatement`
      Creates the packet that contains the query to be sent to the server.
      Overrides:
        `fillSendPacket` in class `PreparedStatement`
      Returns:
        A Buffer filled with the query representing the PreparedStatement.
      Throws:
        `java.sql.SQLException` - if an error occurs.
      See Also:
        `PreparedStatement.fillSendPacket()`

    - #### fillSendPacket

          protected Buffer fillSendPacket(byte[][] batchedParameterStrings,
                              java.io.InputStream[] batchedParameterStreams,
                              boolean[] batchedIsStream,
                              int[] batchedStreamLengths)
                                   throws java.sql.SQLException

      Description copied from class: `PreparedStatement`
      Creates the packet that contains the query to be sent to the server.
      Overrides:
        `fillSendPacket` in class `PreparedStatement`
      Parameters:
        `batchedParameterStrings` - the parameters as strings
        `batchedParameterStreams` - the parameters as streams
        `batchedIsStream` - is the given parameter a stream?
        `batchedStreamLengths` - the lengths of the streams (if appropriate)
      Returns:
        a Buffer filled with the query that represents this statement
      Throws:
        `java.sql.SQLException` - if an error occurs.
      See Also:
        `com.mysql.jdbc.PreparedStatement#fillSendPacket(byte, java.io.InputStream, boolean, int)`

    - #### getBinding

          protected ServerPreparedStatement.BindValue getBinding(int parameterIndex,
                                                     boolean forLongData)
                                                          throws java.sql.SQLException

      Returns the structure representing the value that (can be)/(is) bound at the given parameter index.
      Parameters:
        `parameterIndex` - 1-based
        `forLongData` - is this for a stream?
      Throws:
        `java.sql.SQLException`

    - #### getParameterBindValues

          public ServerPreparedStatement.BindValue[] getParameterBindValues()

      Return current bind values for use by Statement Interceptors.
      Returns:
        the bind values as set by setXXX and stored by addBatch
      See Also:
        `StatementImpl.executeBatch()`, `addBatch()`

    - #### getBytes

          byte[] getBytes(int parameterIndex)
                    throws java.sql.SQLException

      Throws:
        `java.sql.SQLException`
      See Also:
        `com.mysql.jdbc.PreparedStatement#getBytes(int)`

    - #### getMetaData

          public java.sql.ResultSetMetaData getMetaData()
                                                 throws java.sql.SQLException

      Description copied from class: `PreparedStatement`
      The number, types and properties of a ResultSet's columns are provided by the getMetaData method.
      Specified by:
        `getMetaData` in interface `java.sql.PreparedStatement`
      Overrides:
        `getMetaData` in class `PreparedStatement`
      Returns:
        the description of a ResultSet's columns
      Throws:
        `java.sql.SQLException` - if a database-access error occurs.
      See Also:
        `PreparedStatement.getMetaData()`

    - #### getParameterMetaData

          public java.sql.ParameterMetaData getParameterMetaData()
                                                          throws java.sql.SQLException

      Specified by:
        `getParameterMetaData` in interface `java.sql.PreparedStatement`
      Overrides:
        `getParameterMetaData` in class `PreparedStatement`
      Throws:
        `java.sql.SQLException`
      See Also:
        `PreparedStatement.getParameterMetaData()`

    - #### isNull

          boolean isNull(int paramIndex)

      Overrides:
        `isNull` in class `PreparedStatement`
      See Also:
        `PreparedStatement.isNull(int)`

    - #### realClose

          protected void realClose(boolean calledExplicitly,
                       boolean closeOpenResults)
                            throws java.sql.SQLException

      Closes this connection and frees all resources.
      Overrides:
        `realClose` in class `PreparedStatement`
      Parameters:
        `calledExplicitly` - was this called from close()?
      Throws:
        `java.sql.SQLException` - if an error occurs

    - #### rePrepare

          protected void rePrepare()
                            throws java.sql.SQLException

      Used by Connection when auto-reconnecting to retrieve 'lost' prepared statements.
      Throws:
        `java.sql.SQLException` - if an error occurs.

    - #### setArray

          public void setArray(int i,
                      java.sql.Array x)
                        throws java.sql.SQLException

      Description copied from class: `PreparedStatement`
      JDBC 2.0 Set an Array parameter.
      Specified by:
        `setArray` in interface `java.sql.PreparedStatement`
      Overrides:
        `setArray` in class `PreparedStatement`
      Parameters:
        `i` - the first parameter is 1, the second is 2, ...
        `x` - an object representing an SQL array
      Throws:
        `java.sql.SQLException` - because this method is not implemented.
        `NotImplemented`
      See Also:
        `PreparedStatement.setArray(int, java.sql.Array)`

    - #### setAsciiStream

          public void setAsciiStream(int parameterIndex,
                            java.io.InputStream x,
                            int length)
                              throws java.sql.SQLException

      Description copied from class: `PreparedStatement`
      When a very large ASCII value is input to a LONGVARCHAR parameter, it may be more practical to send it via a java.io.InputStream. JDBC will read the data from the stream as needed, until it reaches end-of-file. The JDBC driver will do any necessary conversion from ASCII to the database char format.

      Note: This stream object can either be a standard Java stream object or your own subclass that implements the standard interface.

      Specified by:
        `setAsciiStream` in interface `java.sql.PreparedStatement`
      Overrides:
        `setAsciiStream` in class `PreparedStatement`
      Parameters:
        `parameterIndex` - the first parameter is 1...
        `x` - the parameter value
        `length` - the number of bytes in the stream
      Throws:
        `java.sql.SQLException` - if a database access error occurs
      See Also:
        `PreparedStatement.setAsciiStream(int, java.io.InputStream, int)`

    - #### setBigDecimal

          public void setBigDecimal(int parameterIndex,
                           java.math.BigDecimal x)
                             throws java.sql.SQLException

      Description copied from class: `PreparedStatement`
      Set a parameter to a java.math.BigDecimal value. The driver converts this to a SQL NUMERIC value when it sends it to the database.
      Specified by:
        `setBigDecimal` in interface `java.sql.PreparedStatement`
      Overrides:
        `setBigDecimal` in class `PreparedStatement`
      Parameters:
        `parameterIndex` - the first parameter is 1...
        `x` - the parameter value
      Throws:
        `java.sql.SQLException` - if a database access error occurs
      See Also:
        `PreparedStatement.setBigDecimal(int, java.math.BigDecimal)`

    - #### setBinaryStream

          public void setBinaryStream(int parameterIndex,
                             java.io.InputStream x,
                             int length)
                               throws java.sql.SQLException

      Description copied from class: `PreparedStatement`
      When a very large binary value is input to a LONGVARBINARY parameter, it may be more practical to send it via a java.io.InputStream. JDBC will read the data from the stream as needed, until it reaches end-of-file.

      Note: This stream object can either be a standard Java stream object or your own subclass that implements the standard interface.

      Specified by:
        `setBinaryStream` in interface `java.sql.PreparedStatement`
      Overrides:
        `setBinaryStream` in class `PreparedStatement`
      Parameters:
        `parameterIndex` - the first parameter is 1...
        `x` - the parameter value
        `length` - the number of bytes to read from the stream (ignored)
      Throws:
        `java.sql.SQLException` - if a database access error occurs
      See Also:
        `PreparedStatement.setBinaryStream(int, java.io.InputStream, int)`

    - #### setBlob

          public void setBlob(int parameterIndex,
                     java.sql.Blob x)
                       throws java.sql.SQLException

      Description copied from class: `PreparedStatement`
      JDBC 2.0 Set a BLOB parameter.
      Specified by:
        `setBlob` in interface `java.sql.PreparedStatement`
      Overrides:
        `setBlob` in class `PreparedStatement`
      Parameters:
        `parameterIndex` - the first parameter is 1, the second is 2, ...
        `x` - an object representing a BLOB
      Throws:
        `java.sql.SQLException` - if a database error occurs
      See Also:
        `PreparedStatement.setBlob(int, java.sql.Blob)`

    - #### setBoolean

          public void setBoolean(int parameterIndex,
                        boolean x)
                          throws java.sql.SQLException

      Description copied from class: `PreparedStatement`
      Set a parameter to a Java boolean value. The driver converts this to a SQL BIT value when it sends it to the database.
      Specified by:
        `setBoolean` in interface `java.sql.PreparedStatement`
      Overrides:
        `setBoolean` in class `PreparedStatement`
      Parameters:
        `parameterIndex` - the first parameter is 1...
        `x` - the parameter value
      Throws:
        `java.sql.SQLException` - if a database access error occurs
      See Also:
        `PreparedStatement.setBoolean(int, boolean)`

    - #### setByte

          public void setByte(int parameterIndex,
                     byte x)
                       throws java.sql.SQLException

      Description copied from class: `PreparedStatement`
      Set a parameter to a Java byte value. The driver converts this to a SQL TINYINT value when it sends it to the database.
      Specified by:
        `setByte` in interface `java.sql.PreparedStatement`
      Overrides:
        `setByte` in class `PreparedStatement`
      Parameters:
        `parameterIndex` - the first parameter is 1...
        `x` - the parameter value
      Throws:
        `java.sql.SQLException` - if a database access error occurs
      See Also:
        `PreparedStatement.setByte(int, byte)`

    - #### setBytes

          public void setBytes(int parameterIndex,
                      byte[] x)
                        throws java.sql.SQLException

      Description copied from class: `PreparedStatement`
      Set a parameter to a Java array of bytes. The driver converts this to a SQL VARBINARY or LONGVARBINARY (depending on the argument's size relative to the driver's limits on VARBINARYs) when it sends it to the database.
      Specified by:
        `setBytes` in interface `java.sql.PreparedStatement`
      Overrides:
        `setBytes` in class `PreparedStatement`
      Parameters:
        `parameterIndex` - the first parameter is 1...
        `x` - the parameter value
      Throws:
        `java.sql.SQLException` - if a database access error occurs
      See Also:
        `java.sql.PreparedStatement#setBytes(int, byte)`

    - #### setCharacterStream

          public void setCharacterStream(int parameterIndex,
                                java.io.Reader reader,
                                int length)
                                  throws java.sql.SQLException

      Description copied from class: `PreparedStatement`
      JDBC 2.0 When a very large UNICODE value is input to a LONGVARCHAR parameter, it may be more practical to send it via a java.io.Reader. JDBC will read the data from the stream as needed, until it reaches end-of-file. The JDBC driver will do any necessary conversion from UNICODE to the database char format.

      Note: This stream object can either be a standard Java stream object or your own subclass that implements the standard interface.

      Specified by:
        `setCharacterStream` in interface `java.sql.PreparedStatement`
      Overrides:
        `setCharacterStream` in class `PreparedStatement`
      Parameters:
        `parameterIndex` - the first parameter is 1, the second is 2, ...
        `reader` - the java reader which contains the UNICODE data
        `length` - the number of characters in the stream
      Throws:
        `java.sql.SQLException` - if a database-access error occurs.
      See Also:
        `PreparedStatement.setCharacterStream(int, java.io.Reader, int)`

    - #### setClob

          public void setClob(int parameterIndex,
                     java.sql.Clob x)
                       throws java.sql.SQLException

      Description copied from class: `PreparedStatement`
      JDBC 2.0 Set a CLOB parameter.
      Specified by:
        `setClob` in interface `java.sql.PreparedStatement`
      Overrides:
        `setClob` in class `PreparedStatement`
      Parameters:
        `parameterIndex` - the first parameter is 1, the second is 2, ...
        `x` - an object representing a CLOB
      Throws:
        `java.sql.SQLException` - if a database error occurs
      See Also:
        `PreparedStatement.setClob(int, java.sql.Clob)`

    - #### setDate

          public void setDate(int parameterIndex,
                     java.sql.Date x)
                       throws java.sql.SQLException

      Set a parameter to a java.sql.Date value. The driver converts this to a SQL DATE value when it sends it to the database.
      Specified by:
        `setDate` in interface `java.sql.PreparedStatement`
      Overrides:
        `setDate` in class `PreparedStatement`
      Parameters:
        `parameterIndex` - the first parameter is 1, the second is 2, ...
        `x` - the parameter value
      Throws:
        `java.sql.SQLException` - if a database-access error occurs.

    - #### setDate

          public void setDate(int parameterIndex,
                     java.sql.Date x,
                     java.util.Calendar cal)
                       throws java.sql.SQLException

      Set a parameter to a java.sql.Date value. The driver converts this to a SQL DATE value when it sends it to the database.
      Specified by:
        `setDate` in interface `java.sql.PreparedStatement`
      Overrides:
        `setDate` in class `PreparedStatement`
      Parameters:
        `parameterIndex` - the first parameter is 1, the second is 2, ...
        `x` - the parameter value
        `cal` - the calendar to interpret the date with
      Throws:
        `java.sql.SQLException` - if a database-access error occurs.

    - #### setDouble

          public void setDouble(int parameterIndex,
                       double x)
                         throws java.sql.SQLException

      Description copied from class: `PreparedStatement`
      Set a parameter to a Java double value. The driver converts this to a SQL DOUBLE value when it sends it to the database
      Specified by:
        `setDouble` in interface `java.sql.PreparedStatement`
      Overrides:
        `setDouble` in class `PreparedStatement`
      Parameters:
        `parameterIndex` - the first parameter is 1...
        `x` - the parameter value
      Throws:
        `java.sql.SQLException` - if a database access error occurs
      See Also:
        `PreparedStatement.setDouble(int, double)`

    - #### setFloat

          public void setFloat(int parameterIndex,
                      float x)
                        throws java.sql.SQLException

      Description copied from class: `PreparedStatement`
      Set a parameter to a Java float value. The driver converts this to a SQL FLOAT value when it sends it to the database.
      Specified by:
        `setFloat` in interface `java.sql.PreparedStatement`
      Overrides:
        `setFloat` in class `PreparedStatement`
      Parameters:
        `parameterIndex` - the first parameter is 1...
        `x` - the parameter value
      Throws:
        `java.sql.SQLException` - if a database access error occurs
      See Also:
        `PreparedStatement.setFloat(int, float)`

    - #### setInt

          public void setInt(int parameterIndex,
                    int x)
                      throws java.sql.SQLException

      Description copied from class: `PreparedStatement`
      Set a parameter to a Java int value. The driver converts this to a SQL INTEGER value when it sends it to the database.
      Specified by:
        `setInt` in interface `java.sql.PreparedStatement`
      Overrides:
        `setInt` in class `PreparedStatement`
      Parameters:
        `parameterIndex` - the first parameter is 1...
        `x` - the parameter value
      Throws:
        `java.sql.SQLException` - if a database access error occurs
      See Also:
        `PreparedStatement.setInt(int, int)`

    - #### setLong

          public void setLong(int parameterIndex,
                     long x)
                       throws java.sql.SQLException

      Description copied from class: `PreparedStatement`
      Set a parameter to a Java long value. The driver converts this to a SQL BIGINT value when it sends it to the database.
      Specified by:
        `setLong` in interface `java.sql.PreparedStatement`
      Overrides:
        `setLong` in class `PreparedStatement`
      Parameters:
        `parameterIndex` - the first parameter is 1...
        `x` - the parameter value
      Throws:
        `java.sql.SQLException` - if a database access error occurs
      See Also:
        `PreparedStatement.setLong(int, long)`

    - #### setNull

          public void setNull(int parameterIndex,
                     int sqlType)
                       throws java.sql.SQLException

      Description copied from class: `PreparedStatement`
      Set a parameter to SQL NULL

      Note: You must specify the parameters SQL type (although MySQL ignores it)

      Specified by:
        `setNull` in interface `java.sql.PreparedStatement`
      Overrides:
        `setNull` in class `PreparedStatement`
      Parameters:
        `parameterIndex` - the first parameter is 1, etc...
        `sqlType` - the SQL type code defined in java.sql.Types
      Throws:
        `java.sql.SQLException` - if a database access error occurs
      See Also:
        `PreparedStatement.setNull(int, int)`

    - #### setNull

          public void setNull(int parameterIndex,
                     int sqlType,
                     java.lang.String typeName)
                       throws java.sql.SQLException

      Description copied from class: `PreparedStatement`
      Set a parameter to SQL NULL.

      Note: You must specify the parameter's SQL type.

      Specified by:
        `setNull` in interface `java.sql.PreparedStatement`
      Overrides:
        `setNull` in class `PreparedStatement`
      Parameters:
        `parameterIndex` - the first parameter is 1, the second is 2, ...
        `sqlType` - SQL type code defined by java.sql.Types
        `typeName` - argument parameters for null
      Throws:
        `java.sql.SQLException` - if a database-access error occurs.
      See Also:
        `PreparedStatement.setNull(int, int, java.lang.String)`

    - #### setRef

          public void setRef(int i,
                    java.sql.Ref x)
                      throws java.sql.SQLException

      Description copied from class: `PreparedStatement`
      JDBC 2.0 Set a REF(<structured-type>) parameter.
      Specified by:
        `setRef` in interface `java.sql.PreparedStatement`
      Overrides:
        `setRef` in class `PreparedStatement`
      Parameters:
        `i` - the first parameter is 1, the second is 2, ...
        `x` - an object representing data of an SQL REF Type
      Throws:
        `java.sql.SQLException` - if a database error occurs
        `NotImplemented`
      See Also:
        `PreparedStatement.setRef(int, java.sql.Ref)`

    - #### setShort

          public void setShort(int parameterIndex,
                      short x)
                        throws java.sql.SQLException

      Description copied from class: `PreparedStatement`
      Set a parameter to a Java short value. The driver converts this to a SQL SMALLINT value when it sends it to the database.
      Specified by:
        `setShort` in interface `java.sql.PreparedStatement`
      Overrides:
        `setShort` in class `PreparedStatement`
      Parameters:
        `parameterIndex` - the first parameter is 1...
        `x` - the parameter value
      Throws:
        `java.sql.SQLException` - if a database access error occurs
      See Also:
        `PreparedStatement.setShort(int, short)`

    - #### setString

          public void setString(int parameterIndex,
                       java.lang.String x)
                         throws java.sql.SQLException

      Description copied from class: `PreparedStatement`
      Set a parameter to a Java String value. The driver converts this to a SQL VARCHAR or LONGVARCHAR value (depending on the arguments size relative to the driver's limits on VARCHARs) when it sends it to the database.
      Specified by:
        `setString` in interface `java.sql.PreparedStatement`
      Overrides:
        `setString` in class `PreparedStatement`
      Parameters:
        `parameterIndex` - the first parameter is 1...
        `x` - the parameter value
      Throws:
        `java.sql.SQLException` - if a database access error occurs
      See Also:
        `PreparedStatement.setString(int, java.lang.String)`

    - #### setTime

          public void setTime(int parameterIndex,
                     java.sql.Time x)
                       throws java.sql.SQLException

      Set a parameter to a java.sql.Time value.
      Specified by:
        `setTime` in interface `java.sql.PreparedStatement`
      Overrides:
        `setTime` in class `PreparedStatement`
      Parameters:
        `parameterIndex` - the first parameter is 1...));
        `x` - the parameter value
      Throws:
        `java.sql.SQLException` - if a database access error occurs

    - #### setTime

          public void setTime(int parameterIndex,
                     java.sql.Time x,
                     java.util.Calendar cal)
                       throws java.sql.SQLException

      Set a parameter to a java.sql.Time value. The driver converts this to a SQL TIME value when it sends it to the database, using the given timezone.
      Specified by:
        `setTime` in interface `java.sql.PreparedStatement`
      Overrides:
        `setTime` in class `PreparedStatement`
      Parameters:
        `parameterIndex` - the first parameter is 1...));
        `x` - the parameter value
        `cal` - the timezone to use
      Throws:
        `java.sql.SQLException` - if a database access error occurs

    - #### setTimestamp

          public void setTimestamp(int parameterIndex,
                          java.sql.Timestamp x)
                            throws java.sql.SQLException

      Set a parameter to a java.sql.Timestamp value. The driver converts this to a SQL TIMESTAMP value when it sends it to the database.
      Specified by:
        `setTimestamp` in interface `java.sql.PreparedStatement`
      Overrides:
        `setTimestamp` in class `PreparedStatement`
      Parameters:
        `parameterIndex` - the first parameter is 1, the second is 2, ...
        `x` - the parameter value
      Throws:
        `java.sql.SQLException` - if a database-access error occurs.

    - #### setTimestamp

          public void setTimestamp(int parameterIndex,
                          java.sql.Timestamp x,
                          java.util.Calendar cal)
                            throws java.sql.SQLException

      Set a parameter to a java.sql.Timestamp value. The driver converts this to a SQL TIMESTAMP value when it sends it to the database.
      Specified by:
        `setTimestamp` in interface `java.sql.PreparedStatement`
      Overrides:
        `setTimestamp` in class `PreparedStatement`
      Parameters:
        `parameterIndex` - the first parameter is 1, the second is 2, ...
        `x` - the parameter value
        `cal` - the timezone to use
      Throws:
        `java.sql.SQLException` - if a database-access error occurs.

    - #### setType

          protected void setType(ServerPreparedStatement.BindValue oldValue,
                     int bufferType)
                          throws java.sql.SQLException

      Throws:
        `java.sql.SQLException`

    - #### setUnicodeStream

          @Deprecated
          public void setUnicodeStream(int parameterIndex,
                                         java.io.InputStream x,
                                         int length)
                                throws java.sql.SQLException

      Deprecated.
      Description copied from class: `PreparedStatement`
      When a very large Unicode value is input to a LONGVARCHAR parameter, it may be more practical to send it via a java.io.InputStream. JDBC will read the data from the stream as needed, until it reaches end-of-file. The JDBC driver will do any necessary conversion from UNICODE to the database char format.

      Note: This stream object can either be a standard Java stream object or your own subclass that implements the standard interface.

      Specified by:
        `setUnicodeStream` in interface `java.sql.PreparedStatement`
      Overrides:
        `setUnicodeStream` in class `PreparedStatement`
      Parameters:
        `parameterIndex` -
        `x` -
        `length` -
      Throws:
        `java.sql.SQLException`
        `NotImplemented`
      See Also:
        `PreparedStatement.setUnicodeStream(int, java.io.InputStream, int)`

    - #### setURL

          public void setURL(int parameterIndex,
                    java.net.URL x)
                      throws java.sql.SQLException

      Specified by:
        `setURL` in interface `java.sql.PreparedStatement`
      Overrides:
        `setURL` in class `PreparedStatement`
      Throws:
        `java.sql.SQLException`
      See Also:
        `PreparedStatement.setURL(int, java.net.URL)`

    - #### toString

          public java.lang.String toString()

      Description copied from class: `PreparedStatement`
      Returns this PreparedStatement represented as a string.
      Overrides:
        `toString` in class `PreparedStatement`
      Returns:
        this PreparedStatement represented as a string.
      See Also:
        `Object.toString()`

    - #### getServerStatementId

          protected long getServerStatementId()

    - #### canRewriteAsMultiValueInsertAtSqlLevel

          public boolean canRewriteAsMultiValueInsertAtSqlLevel()
                                                         throws java.sql.SQLException

      Overrides:
        `canRewriteAsMultiValueInsertAtSqlLevel` in class `PreparedStatement`
      Throws:
        `java.sql.SQLException`

    - #### canRewriteAsMultivalueInsertStatement

          public boolean canRewriteAsMultivalueInsertStatement()
                                                        throws java.sql.SQLException

      Throws:
        `java.sql.SQLException`

    - #### getLocationOfOnDuplicateKeyUpdate

          protected int getLocationOfOnDuplicateKeyUpdate()
                                                   throws java.sql.SQLException

      Overrides:
        `getLocationOfOnDuplicateKeyUpdate` in class `PreparedStatement`
      Throws:
        `java.sql.SQLException`

    - #### isOnDuplicateKeyUpdate

          protected boolean isOnDuplicateKeyUpdate()
                                            throws java.sql.SQLException

      Throws:
        `java.sql.SQLException`

    - #### computeMaxParameterSetSizeAndBatchSize

          protected long[] computeMaxParameterSetSizeAndBatchSize(int numBatchedArgs)
                                                           throws java.sql.SQLException

      Computes the maximum parameter set size, and entire batch size given the number of arguments in the batch.
      Overrides:
        `computeMaxParameterSetSizeAndBatchSize` in class `PreparedStatement`
      Throws:
        `java.sql.SQLException`

    - #### setOneBatchedParameterSet

          protected int setOneBatchedParameterSet(java.sql.PreparedStatement batchedStatement,
                                      int batchedParamIndex,
                                      java.lang.Object paramSet)
                                           throws java.sql.SQLException

      Overrides:
        `setOneBatchedParameterSet` in class `PreparedStatement`
      Throws:
        `java.sql.SQLException`

    - #### containsOnDuplicateKeyUpdateInSQL

          protected boolean containsOnDuplicateKeyUpdateInSQL()

      Overrides:
        `containsOnDuplicateKeyUpdateInSQL` in class `PreparedStatement`

    - #### prepareBatchedInsertSQL

          protected PreparedStatement prepareBatchedInsertSQL(MySQLConnection localConn,
                                                  int numBatches)
                                                       throws java.sql.SQLException

      Description copied from class: `PreparedStatement`
      Returns a prepared statement for the number of batched parameters, used when re-writing batch INSERTs.
      Overrides:
        `prepareBatchedInsertSQL` in class `PreparedStatement`
      Throws:
        `java.sql.SQLException`