Package org.mariadb.jdbc

## Class ServerPreparedStatement

- java.lang.Object
- - org.mariadb.jdbc.Statement
  - - org.mariadb.jdbc.BasePreparedStatement
    - - org.mariadb.jdbc.ServerPreparedStatement

All Implemented Interfaces:
  `AutoCloseable`, `PreparedStatement`, `Statement`, `Wrapper`

Direct Known Subclasses:
  `BaseCallableStatement`

    public class ServerPreparedStatement
    extends BasePreparedStatement

### Field Summary

### Fields inherited from class org.mariadb.jdbc.BasePreparedStatement

`batchParameters, parameters, prepareResult, sql`

### Fields inherited from class org.mariadb.jdbc.Statement

`autoGeneratedKeys, canUseServerMaxRows, canUseServerTimeout, closed, closeOnCompletion, con, currResult, escape, fetchSize, lock, maxRows, queryTimeout, results, resultSetConcurrency, resultSetType`

### 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
`ServerPreparedStatement​(String sql, Connection con, ReentrantLock lock, boolean canUseServerTimeout, boolean canUseServerMaxRows, int autoGeneratedKeys, int resultSetType, int resultSetConcurrency, int defaultFetchSize)`

### Method Summary

All Methods Instance Methods Concrete Methods
`void` `addBatch()` Adds a set of parameters to this `PreparedStatement` object's batch of commands.
`void` `close()` Releases this `Statement` object's database and JDBC resources immediately instead of waiting for this to happen when it is automatically closed.
`boolean` `execute()` Executes the SQL statement in this `PreparedStatement` object, which may be any kind of SQL statement.
`int[]` `executeBatch()` Submits a batch of commands to the database for execution and if all commands execute successfully, returns an array of update counts.
`protected void` `executeInternal()`
`long[]` `executeLargeBatch()` Execute batch, like executeBatch(), with returning results with long[].
`long` `executeLargeUpdate()` Executes the SQL statement in this `PreparedStatement` object, which must be an SQL Data Manipulation Language (DML) statement, such as `INSERT`, `UPDATE` or `DELETE`; or an SQL statement that returns nothing, such as a DDL statement.
`ResultSet` `executeQuery()` Executes the SQL query in this `PreparedStatement` object and returns the `ResultSet` object generated by the query.
`int` `executeUpdate()` Executes the SQL statement in this `PreparedStatement` object, which must be an SQL Data Manipulation Language (DML) statement, such as `INSERT`, `UPDATE` or `DELETE`; or an SQL statement that returns nothing, such as a DDL statement.
`ResultSetMetaData` `getMetaData()` Retrieves a `ResultSetMetaData` object that contains information about the columns of the `ResultSet` object that will be returned when this `PreparedStatement` object is executed.
`ParameterMetaData` `getParameterMetaData()` Retrieves the number, types and properties of this `PreparedStatement` object's parameters.
`protected void` `handleParameterOutput()`
`void` `reset()`
`void` `setLargeMaxRows​(long max)` Sets the limit for the maximum number of rows that any ResultSet object generated by this Statement object can contain to the given number.
`void` `setMaxRows​(int max)` Sets the limit for the maximum number of rows that any `ResultSet` object generated by this `Statement` object can contain to the given number.
`void` `setQueryTimeout​(int seconds)` Sets the number of seconds the driver will wait for a `Statement` object to execute to the given number of seconds.
`protected void` `validParameters()`

### Methods inherited from class org.mariadb.jdbc.BasePreparedStatement

`addBatch, clearParameters, execute, execute, execute, execute, executeLargeUpdate, executeLargeUpdate, executeLargeUpdate, executeLargeUpdate, executeQuery, executeUpdate, executeUpdate, executeUpdate, executeUpdate, getMeta, setArray, setAsciiStream, setAsciiStream, setAsciiStream, setBigDecimal, setBinaryStream, setBinaryStream, setBinaryStream, setBlob, setBlob, setBlob, setBoolean, setByte, setBytes, setCharacterStream, setCharacterStream, setCharacterStream, setClob, setClob, setClob, setDate, setDate, setDouble, setFloat, setInt, setLong, setNCharacterStream, setNCharacterStream, setNClob, setNClob, setNClob, setNString, setNull, setNull, setObject, setObject, setObject, setObject, setObject, setParameter, setParameters, setPrepareResult, setRef, setRowId, setShort, setSQLXML, setString, setTime, setTime, setTimestamp, setTimestamp, setUnicodeStream, setURL, updateMeta`

### Methods inherited from class org.mariadb.jdbc.Statement

`abort, cancel, checkNotClosed, clearBatch, clearWarnings, closeOnCompletion, escapeTimeout, executeInternalBatchPipeline, executeInternalBatchStandard, fetchRemaining, getConnection, getFetchDirection, getFetchSize, getGeneratedKeys, getLargeMaxRows, getLargeUpdateCount, getMaxFieldSize, getMaxRows, getMoreResults, getMoreResults, getQueryTimeout, getResultSet, getResultSetConcurrency, getResultSetHoldability, getResultSetType, getUpdateCount, getWarnings, isClosed, isCloseOnCompletion, isPoolable, isWrapperFor, setCursorName, setEscapeProcessing, setFetchDirection, setFetchSize, setMaxFieldSize, setPoolable, unwrap`

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

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

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

`cancel, clearBatch, clearWarnings, closeOnCompletion, enquoteIdentifier, enquoteLiteral, enquoteNCharLiteral, getConnection, getFetchDirection, getFetchSize, getGeneratedKeys, getLargeMaxRows, getLargeUpdateCount, getMaxFieldSize, getMaxRows, getMoreResults, getMoreResults, getQueryTimeout, getResultSet, getResultSetConcurrency, getResultSetHoldability, getResultSetType, getUpdateCount, getWarnings, isClosed, isCloseOnCompletion, isPoolable, isSimpleIdentifier, setCursorName, setEscapeProcessing, setFetchDirection, setFetchSize, setMaxFieldSize, setPoolable`

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

`isWrapperFor, unwrap`

### Constructor Detail

#### ServerPreparedStatement

    public ServerPreparedStatement​(String sql,
                                   Connection con,
                                   ReentrantLock lock,
                                   boolean canUseServerTimeout,
                                   boolean canUseServerMaxRows,
                                   int autoGeneratedKeys,
                                   int resultSetType,
                                   int resultSetConcurrency,
                                   int defaultFetchSize)
                            throws SQLException

Throws:
  `SQLException`

### Method Detail

#### executeInternal

    protected void executeInternal()
                            throws SQLException

Throws:
  `SQLException`

#### execute

    public boolean execute()
                    throws SQLException

Executes the SQL statement in this `PreparedStatement` object, which may be any kind of SQL statement. Some prepared statements return multiple results; the `execute` method handles these complex statements as well as the simpler form of statements handled by the methods `executeQuery` and `executeUpdate`.

The `execute` method returns a `boolean` to indicate the form of the first result. You must call either the method `getResultSet` or `getUpdateCount` to retrieve the result; you must call `getMoreResults` to move to any subsequent result(s).

Specified by:
  `execute` in interface `PreparedStatement`
Specified by:
  `execute` in class `BasePreparedStatement`
Returns:
  `true` if the first result is a `ResultSet` object; `false` if the first result is an update count or there is no result
Throws:
  `SQLException` - if a database access error occurs; this method is called on a closed `PreparedStatement` or an argument is supplied to this method
  `SQLTimeoutException` - when the driver has determined that the timeout value that was specified by the `setQueryTimeout` method has been exceeded and has at least attempted to cancel the currently running `Statement`
See Also:
  `Statement.execute(java.lang.String)`, `Statement.getResultSet()`, `Statement.getUpdateCount()`, `Statement.getMoreResults()`

#### setMaxRows

    public void setMaxRows​(int max)
                    throws SQLException

Description copied from class: `Statement`
Sets the limit for the maximum number of rows that any `ResultSet` object generated by this `Statement` object can contain to the given number. If the limit is exceeded, the excess rows are silently dropped.

Specified by:
  `setMaxRows` in interface `Statement`
Overrides:
  `setMaxRows` in class `Statement`
Parameters:
  `max` - the new max rows limit; zero means there is no limit
Throws:
  `SQLException` - if a database access error occurs, this method is called on a closed `Statement` or the condition `max >= 0` is not satisfied
See Also:
  `Statement.getMaxRows()`

#### setLargeMaxRows

    public void setLargeMaxRows​(long max)
                         throws SQLException

Description copied from class: `Statement`
Sets the limit for the maximum number of rows that any ResultSet object generated by this Statement object can contain to the given number. If the limit is exceeded, the excess rows are silently dropped.

Specified by:
  `setLargeMaxRows` in interface `Statement`
Overrides:
  `setLargeMaxRows` in class `Statement`
Parameters:
  `max` - the new max rows limit; zero means there is no limit
Throws:
  `SQLException` - if the condition max >= 0 is not satisfied

#### setQueryTimeout

    public void setQueryTimeout​(int seconds)
                         throws SQLException

Description copied from class: `Statement`
Sets the number of seconds the driver will wait for a `Statement` object to execute to the given number of seconds. By default, there is no limit on the amount of time allowed for a running statement to complete. If the limit is exceeded, an `SQLTimeoutException` is thrown. A JDBC driver must apply this limit to the `execute`, `executeQuery` and `executeUpdate` methods.

Note: JDBC driver implementations may also apply this limit to `ResultSet` methods (consult your driver vendor documentation for details).

Note: In the case of `Statement` batching, it is implementation defined whether the time-out is applied to individual SQL commands added via the `addBatch` method or to the entire batch of SQL commands invoked by the `executeBatch` method (consult your driver vendor documentation for details).

Specified by:
  `setQueryTimeout` in interface `Statement`
Overrides:
  `setQueryTimeout` in class `Statement`
Parameters:
  `seconds` - the new query timeout limit in seconds; zero means there is no limit
Throws:
  `SQLException` - if a database access error occurs, this method is called on a closed `Statement` or the condition `seconds >= 0` is not satisfied
See Also:
  `Statement.getQueryTimeout()`

#### executeQuery

    public ResultSet executeQuery()
                           throws SQLException

Executes the SQL query in this `PreparedStatement` object and returns the `ResultSet` object generated by the query.

Specified by:
  `executeQuery` in interface `PreparedStatement`
Specified by:
  `executeQuery` in class `BasePreparedStatement`
Returns:
  a `ResultSet` object that contains the data produced by the query; never `null`
Throws:
  `SQLException` - if a database access error occurs; this method is called on a closed `PreparedStatement` or the SQL statement does not return a `ResultSet` object
  `SQLTimeoutException` - when the driver has determined that the timeout value that was specified by the `setQueryTimeout` method has been exceeded and has at least attempted to cancel the currently running `Statement`

#### executeUpdate

    public int executeUpdate()
                      throws SQLException

Executes the SQL statement in this `PreparedStatement` object, which must be an SQL Data Manipulation Language (DML) statement, such as `INSERT`, `UPDATE` or `DELETE`; or an SQL statement that returns nothing, such as a DDL statement.

Specified by:
  `executeUpdate` in interface `PreparedStatement`
Specified by:
  `executeUpdate` in class `BasePreparedStatement`
Returns:
  either (1) the row count for SQL Data Manipulation Language (DML) statements or (2) 0 for SQL statements that return nothing
Throws:
  `SQLException` - if a database access error occurs; this method is called on a closed `PreparedStatement` or the SQL statement returns a `ResultSet` object
  `SQLTimeoutException` - when the driver has determined that the timeout value that was specified by the `setQueryTimeout` method has been exceeded and has at least attempted to cancel the currently running `Statement`

#### executeLargeUpdate

    public long executeLargeUpdate()
                            throws SQLException

Executes the SQL statement in this `PreparedStatement` object, which must be an SQL Data Manipulation Language (DML) statement, such as `INSERT`, `UPDATE` or `DELETE`; or an SQL statement that returns nothing, such as a DDL statement.

This method should be used when the returned row count may exceed `Integer.MAX_VALUE`.

The default implementation will throw `UnsupportedOperationException`

Specified by:
  `executeLargeUpdate` in interface `PreparedStatement`
Specified by:
  `executeLargeUpdate` in class `BasePreparedStatement`
Returns:
  either (1) the row count for SQL Data Manipulation Language (DML) statements or (2) 0 for SQL statements that return nothing
Throws:
  `SQLException` - if a database access error occurs; this method is called on a closed `PreparedStatement` or the SQL statement returns a `ResultSet` object
  `SQLTimeoutException` - when the driver has determined that the timeout value that was specified by the `setQueryTimeout` method has been exceeded and has at least attempted to cancel the currently running `Statement`
Since:
  1.8

#### handleParameterOutput

    protected void handleParameterOutput()
                                  throws SQLException

Throws:
  `SQLException`

#### addBatch

    public void addBatch()
                  throws SQLException

Adds a set of parameters to this `PreparedStatement` object's batch of commands.

Specified by:
  `addBatch` in interface `PreparedStatement`
Specified by:
  `addBatch` in class `BasePreparedStatement`
Throws:
  `SQLException` - if a database access error occurs or this method is called on a closed `PreparedStatement`
Since:
  1.2
See Also:
  `Statement.addBatch(java.lang.String)`

#### validParameters

    protected void validParameters()
                            throws SQLException

Throws:
  `SQLException`

#### getMetaData

    public ResultSetMetaData getMetaData()
                                  throws SQLException

Retrieves a `ResultSetMetaData` object that contains information about the columns of the `ResultSet` object that will be returned when this `PreparedStatement` object is executed.

Because a `PreparedStatement` object is precompiled, it is possible to know about the `ResultSet` object that it will return without having to execute it. Consequently, it is possible to invoke the method `getMetaData` on a `PreparedStatement` object rather than waiting to execute it and then invoking the `ResultSet.getMetaData` method on the `ResultSet` object that is returned.

NOTE: Using this method may be expensive for some drivers due to the lack of underlying DBMS support.

Specified by:
  `getMetaData` in interface `PreparedStatement`
Specified by:
  `getMetaData` in class `BasePreparedStatement`
Returns:
  the description of a `ResultSet` object's columns or `null` if the driver cannot return a `ResultSetMetaData` object
Throws:
  `SQLException` - if a database access error occurs or this method is called on a closed `PreparedStatement`
  `SQLFeatureNotSupportedException` - if the JDBC driver does not support this method
Since:
  1.2

#### getParameterMetaData

    public ParameterMetaData getParameterMetaData()
                                           throws SQLException

Retrieves the number, types and properties of this `PreparedStatement` object's parameters.

Specified by:
  `getParameterMetaData` in interface `PreparedStatement`
Specified by:
  `getParameterMetaData` in class `BasePreparedStatement`
Returns:
  a `ParameterMetaData` object that contains information about the number, types and properties for each parameter marker of this `PreparedStatement` object
Throws:
  `SQLException` - if a database access error occurs or this method is called on a closed `PreparedStatement`
Since:
  1.4
See Also:
  `ParameterMetaData`

#### executeBatch

    public int[] executeBatch()
                       throws SQLException

Description copied from class: `Statement`
Submits a batch of commands to the database for execution and if all commands execute successfully, returns an array of update counts. The `int` elements of the array that is returned are ordered to correspond to the commands in the batch, which are ordered according to the order in which they were added to the batch. The elements in the array returned by the method `executeBatch` may be one of the following:

1. A number greater than or equal to zero -- indicates that the command was processed successfully and is an update count giving the number of rows in the database that were affected by the command's execution
2. A value of `SUCCESS_NO_INFO` -- indicates that the command was processed successfully but that the number of rows affected is unknown

   If one of the commands in a batch update fails to execute properly, this method throws a `BatchUpdateException`, and a JDBC driver may or may not continue to process the remaining commands in the batch. However, the driver's behavior must be consistent with a particular DBMS, either always continuing to process commands or never continuing to process commands. If the driver continues processing after a failure, the array returned by the method `BatchUpdateException.getUpdateCounts` will contain as many elements as there are commands in the batch, and at least one of the elements will be the following:

3. A value of `EXECUTE_FAILED` -- indicates that the command failed to execute successfully and occurs only if a driver continues to process commands after a command fails

The possible implementations and return values have been modified in the Java 2 SDK, Standard Edition, version 1.3 to accommodate the option of continuing to process commands in a batch update after a `BatchUpdateException` object has been thrown.

Specified by:
  `executeBatch` in interface `Statement`
Specified by:
  `executeBatch` in class `BasePreparedStatement`
Returns:
  an array of update counts containing one element for each command in the batch. The elements of the array are ordered according to the order in which commands were added to the batch.
Throws:
  `SQLException` - if a database access error occurs, this method is called on a closed `Statement` or the driver does not support batch statements. Throws `BatchUpdateException` (a subclass of `SQLException`) if one of the commands sent to the database fails to execute properly or attempts to return a result set.
  `SQLTimeoutException` - when the driver has determined that the timeout value that was specified by the `setQueryTimeout` method has been exceeded and has at least attempted to cancel the currently running `Statement`
See Also:
  `Statement.addBatch(java.lang.String)`, `DatabaseMetaData.supportsBatchUpdates()`

#### executeLargeBatch

    public long[] executeLargeBatch()
                             throws SQLException

Description copied from class: `Statement`
Execute batch, like executeBatch(), with returning results with long[]. For when row count may exceed Integer.MAX_VALUE.

Specified by:
  `executeLargeBatch` in interface `Statement`
Specified by:
  `executeLargeBatch` in class `BasePreparedStatement`
Returns:
  an array of update counts (one element for each command in the batch)
Throws:
  `SQLException` - if a database error occur.

#### close

    public void close()
               throws SQLException

Description copied from class: `Statement`
Releases this `Statement` object's database and JDBC resources immediately instead of waiting for this to happen when it is automatically closed. It is generally good practice to release resources as soon as you are finished with them to avoid tying up database resources.

Calling the method `close` on a `Statement` object that is already closed has no effect.

Note:When a `Statement` object is closed, its current `ResultSet` object, if one exists, is also closed.

Specified by:
  `close` in interface `AutoCloseable`
Specified by:
  `close` in interface `Statement`
Overrides:
  `close` in class `Statement`
Throws:
  `SQLException` - if a database access error occurs

#### reset

    public void reset()