: Class PreparedStatement

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## ModSQL
Class PreparedStatement

    java.lang.Object
      |
      +--ModSQL.PreparedStatement

All Implemented Interfaces:
  PreparedStatement, Statement

public class PreparedStatement
extends Object
implements PreparedStatement

An object that represents a precompiled SQL statement. Objects of this class can also be used as `Statement` objects.

Author:
  chris.studholme@utoronto.ca
See Also:
  `Connection.prepareStatement(java.lang.String)`, `ResultSet`

Field Summary
`private Connection` | `connection` Connection that created this statement.
`protected Query` | `query` Current prepared query.
`private DatabaseManager` | `tablemanager` DatabaseManager to use when looking up table names.
`protected int` | `updatecount` Update count that resulted from executing the query.

Constructor Summary
`PreparedStatement(DatabaseManager tablemanager, Connection connection)` Setup an empty statement.
`PreparedStatement(DatabaseManager tablemanager, Connection connection, String sql)` Create a prepared statement and parse the query provided.

Method Summary
`void` | `addBatch()` Adds a set of parameters to this `PreparedStatement` object's batch of commands.
`void` | `addBatch(String sql)` Adds a SQL command to the current batch of commmands for the statement.
`void` | `cancel()` Cancel can be used by one thread to cancel a statement that is being executed by another thread.
`void` | `clearBatch()` Make the set of commands in the current batch empty.
`void` | `clearParameters()` Clears the current parameter values immediately.
`void` | `clearWarnings()` After this call, getWarnings returns null until a new warning is reported for this Statement.
`void` | `close()` In many cases, it is desirable to immediately release a Statements's database and JDBC resources instead of waiting for this to happen when it is automatically closed; the close method provides this immediate release.
`boolean` | `execute()` Executes any kind of SQL statement.
`boolean` | `execute(String sql)` Execute a SQL statement that may return multiple results.
`int[]` | `executeBatch()` Submit a batch of commands to the database for execution.
`ResultSet` | `executeQuery()` Executes the SQL query in this `PreparedStatement` object and returns the result set generated by the query.
`ResultSet` | `executeQuery(String sql)` Execute a SQL statement that returns a single ResultSet.
`int` | `executeUpdate()` Executes the SQL INSERT, UPDATE or DELETE statement in this `PreparedStatement` object.
`int` | `executeUpdate(String sql)` Execute a SQL INSERT, UPDATE or DELETE statement.
`Connection` | `getConnection()` Return the Connection that produced the Statement.
`int` | `getFetchDirection()` Determine the fetch direction.
`int` | `getFetchSize()` Determine the default fetch size.
`int` | `getMaxFieldSize()` The maxFieldSize limit (in bytes) is the maximum amount of data returned for any column value; it only applies to BINARY, VARBINARY, LONGVARBINARY, CHAR, VARCHAR, and LONGVARCHAR columns.
`int` | `getMaxRows()` The maxRows limit is the maximum number of rows that a ResultSet can contain.
`ResultSetMetaData` | `getMetaData()` Gets the number, types and properties of a `ResultSet` object's columns.
`boolean` | `getMoreResults()` getMoreResults moves to a Statement's next result.
`int` | `getQueryTimeout()` The queryTimeout limit is the number of seconds the driver will wait for a Statement to execute.
`ResultSet` | `getResultSet()` getResultSet returns the current result as a ResultSet.
`int` | `getResultSetConcurrency()` Determine the result set concurrency.
`int` | `getResultSetType()` Determine the result set type.
`int` | `getUpdateCount()` getUpdateCount returns the current result as an update count; if the result is a ResultSet or there are no more results, -1 is returned.
`SQLWarning` | `getWarnings()` The first warning reported by calls on this Statement is returned.
`private void` | `parseQuery(String sql)` Parse a SQL query.
`private void` | `ResetStatement()` Close and delete any SQL statement currently prepared.
`void` | `setArray(int i, Array x)` Sets the designated parameter to the given `Array` object.
`void` | `setAsciiStream(int parameterIndex, InputStream x, int length)` Sets the designated parameter to the given input stream, which will have the specified number of bytes.
`void` | `setBigDecimal(int parameterIndex, BigDecimal x)` Sets the designated parameter to a `java.math.BigDecimal` value.
`void` | `setBinaryStream(int parameterIndex, InputStream x, int length)` Sets the designated parameter to the given input stream, which will have the specified number of bytes.
`void` | `setBlob(int i, Blob x)` Sets the designated parameter to the given `Blob` object.
`void` | `setBoolean(int parameterIndex, boolean x)` Sets the designated parameter to a Java `boolean` value.
`void` | `setByte(int parameterIndex, byte x)` Sets the designated parameter to a Java `byte` value.
`void` | `setBytes(int parameterIndex, byte[] x)` Sets the designated parameter to a Java array of bytes.
`void` | `setCharacterStream(int parameterIndex, Reader reader, int length)` Sets the designated parameter to the given `Reader` object, which is the given number of characters long.
`void` | `setClob(int i, Clob x)` Sets the designated parameter to the given `Clob` object.
`void` | `setCursorName(String name)` setCursorname defines the SQL cursor name that will be used by subsequent Statement execute methods.
`void` | `setDate(int parameterIndex, Date x)` Sets the designated parameter to a value.
`void` | `setDate(int parameterIndex, Date x, Calendar cal)` Sets the designated parameter to the given `java.sql.Date` value, using the given `Calendar` object.
`void` | `setDouble(int parameterIndex, double x)` Sets the designated parameter to a Java `double` value.
`void` | `setEscapeProcessing(boolean enable)` If escape scanning is on (the default), the driver will do escape substitution before sending the SQL to the database.
`void` | `setFetchDirection(int direction)` Give a hint as to the direction in which the rows in a result set will be processed.
`void` | `setFetchSize(int rows)` Give the JDBC driver a hint as to the number of rows that should be fetched from the database when more rows are needed.
`void` | `setFloat(int parameterIndex, float x)` Sets the designated parameter to a Java `float` value.
`void` | `setInt(int parameterIndex, int x)` Sets the designated parameter to a Java `int` value.
`void` | `setLong(int parameterIndex, long x)` Sets the designated parameter to a Java `long` value.
`void` | `setMaxFieldSize(int max)` The maxFieldSize limit (in bytes) is set to limit the size of data that can be returned for any column value; it only applies to BINARY, VARBINARY, LONGVARBINARY, CHAR, VARCHAR, and LONGVARCHAR fields.
`void` | `setMaxRows(int max)` The maxRows limit is set to limit the number of rows that any ResultSet can contain.
`void` | `setNull(int parameterIndex, int sqlType)` Sets the designated parameter to SQL `NULL`.
`void` | `setNull(int paramIndex, int sqlType, String typeName)` Sets the designated parameter to SQL `NULL`.
`void` | `setObject(int parameterIndex, Object x)` Sets the value of the designated parameter using the given object.
`void` | `setObject(int parameterIndex, Object x, int targetSqlType)` Sets the value of the designated parameter with the given object.
`void` | `setObject(int parameterIndex, Object x, int targetSqlType, int scale)` Sets the value of the designated parameter with the given object.
`void` | `setQueryTimeout(int seconds)` The queryTimeout limit is the number of seconds the driver will wait for a Statement to execute.
`void` | `setRef(int i, Ref x)` Sets the designated parameter to the given `REF(<structured-type>)` value.
`void` | `setShort(int parameterIndex, short x)` Sets the designated parameter to a Java `short` value.
`void` | `setString(int parameterIndex, String x)` Sets the designated parameter to a Java `String` value.
`void` | `setTime(int parameterIndex, Time x)` Sets the designated parameter to a `java.sql.Time` value.
`void` | `setTime(int parameterIndex, Time x, Calendar cal)` Sets the designated parameter to the given `java.sql.Time` value, using the given `Calendar` object.
`void` | `setTimestamp(int parameterIndex, Timestamp x)` Sets the designated parameter to a `java.sql.Timestamp` value.
`void` | `setTimestamp(int parameterIndex, Timestamp x, Calendar cal)` Sets the designated parameter to the given `java.sql.Timestamp` value, using the given `Calendar` object.
`void` | `setUnicodeStream(int parameterIndex, InputStream x, int length)` Deprecated.
`String` | `toString()` Query as parsed.

Methods inherited from class java.lang.Object
`, clone, equals, finalize, getClass, hashCode, notify, notifyAll, registerNatives, wait, wait, wait`

Field Detail

### tablemanager

    private DatabaseManager tablemanager

  DatabaseManager to use when looking up table names.

### connection

    private Connection connection

  Connection that created this statement.

### query

    protected Query query

  Current prepared query.

### updatecount

    protected int updatecount

  Update count that resulted from executing the query.

Constructor Detail

### PreparedStatement

    public PreparedStatement(DatabaseManager tablemanager,
                             Connection connection)

  Setup an empty statement.
  Parameters:
    `tablemanager` - manager to use when looking up tables
    `connection` - connection that created this statement

### PreparedStatement

    public PreparedStatement(DatabaseManager tablemanager,
                             Connection connection,
                             String sql)
                      throws SQLException

  Create a prepared statement and parse the query provided.
  Parameters:
    `tablemanager` - manager to use when looking up tables
    `connection` - connection that created this statement
    `sql` - query to prepare
  Throws:
    `SQLException` - if an error occurs

Method Detail

### ResetStatement

    private void ResetStatement()
                         throws SQLException

  Close and delete any SQL statement currently prepared.
  Throws:
    `SQLException` - if an error occurs

### close

    public void close()
               throws SQLException

  In many cases, it is desirable to immediately release a Statements'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 `Statement`
  Throws:
    `SQLException` - if a database-access error occurs.

### parseQuery

    private void parseQuery(String sql)
                     throws SQLException

  Parse a SQL query.
  Parameters:
    `sql` - queyr to parse
  Throws:
    `SQLException` - if an error occurs

### executeQuery

    public ResultSet executeQuery(String sql)
                           throws SQLException

  Execute a SQL statement that returns a single ResultSet.
  Specified by:
    `executeQuery` in interface `Statement`
  Parameters:
    `sql` - typically this is a static SQL SELECT statement
  Returns:
    a ResultSet that contains the data produced by the query; never null
  Throws:
    `SQLException` - if a database-access error occurs.

### executeUpdate

    public int executeUpdate(String sql)
                      throws SQLException

  Execute a SQL INSERT, UPDATE or DELETE statement. In addition, SQL statements that return nothing such as SQL DDL statements can be executed.
  Specified by:
    `executeUpdate` in interface `Statement`
  Parameters:
    `sql` - a SQL INSERT, UPDATE or DELETE statement or a SQL statement that returns nothing
  Returns:
    either the row count for INSERT, UPDATE or DELETE or 0 for SQL statements that return nothing
  Throws:
    `SQLException` - if a database-access error occurs.

### execute

    public boolean execute(String sql)
                    throws SQLException

  Execute a SQL statement that may return multiple results. Under some (uncommon) situations a single SQL statement may return multiple result sets and/or update counts. Normally you can ignore this, unless you're executing a stored procedure that you know may return multiple results, or unless you're dynamically executing an unknown SQL string. The "execute", "getMoreResults", "getResultSet" and "getUpdateCount" methods let you navigate through multiple results. The "execute" method executes a SQL statement and indicates the form of the first result. You can then use getResultSet or getUpdateCount to retrieve the result, and getMoreResults to move to any subsequent result(s).
  Specified by:
    `execute` in interface `Statement`
  Parameters:
    `sql` - any SQL statement
  Returns:
    true if the next result is a ResultSet; false if it is an update count or there are no more results
  Throws:
    `SQLException` - if a database-access error occurs.
  See Also:
    `getResultSet()`, `getUpdateCount()`, `getMoreResults()`

### executeQuery

    public ResultSet executeQuery()
                           throws SQLException

  Executes the SQL query in this `PreparedStatement` object and returns the result set generated by the query.
  Specified by:
    `executeQuery` in interface `PreparedStatement`
  Returns:
    a `ResultSet` object that contains the data produced by the query; never `null`
  Throws:
    `SQLException` - if a database access error occurs

### executeUpdate

    public int executeUpdate()
                      throws SQLException

  Executes the SQL INSERT, UPDATE or DELETE statement in this `PreparedStatement` object. In addition, SQL statements that return nothing, such as SQL DDL statements, can be executed.
  Specified by:
    `executeUpdate` in interface `PreparedStatement`
  Returns:
    either the row count for INSERT, UPDATE or DELETE statements; or 0 for SQL statements that return nothing
  Throws:
    `SQLException` - if a database access error occurs

### execute

    public boolean execute()
                    throws SQLException

  Executes 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`.
  Specified by:
    `execute` in interface `PreparedStatement`
  Throws:
    `SQLException` - if a database access error occurs

### getResultSet

    public ResultSet getResultSet()
                           throws SQLException

  getResultSet returns the current result as a ResultSet. It should only be called once per result.
  Specified by:
    `getResultSet` in interface `Statement`
  Returns:
    the current result as a ResultSet; null if the result is an update count or there are no more results
  Throws:
    `SQLException` - if a database-access error occurs.
  See Also:
    `execute(java.lang.String)`

### getMetaData

    public ResultSetMetaData getMetaData()
                                  throws SQLException

  Gets the number, types and properties of a `ResultSet` object's columns.
  Specified by:
    `getMetaData` in interface `PreparedStatement`
  Returns:
    the description of a `ResultSet` object's columns
  Throws:
    `SQLException` - if a database access error occurs

### getUpdateCount

    public int getUpdateCount()
                       throws SQLException

  getUpdateCount returns the current result as an update count; if the result is a ResultSet or there are no more results, -1 is returned. It should only be called once per result.
  Specified by:
    `getUpdateCount` in interface `Statement`
  Returns:
    the current result as an update count; -1 if it is a ResultSet or there are no more results
  Throws:
    `SQLException` - if a database-access error occurs.
  See Also:
    `execute(java.lang.String)`

### getMoreResults

    public boolean getMoreResults()
                           throws SQLException

  getMoreResults moves to a Statement's next result. It returns true if this result is a ResultSet. getMoreResults also implicitly closes any current ResultSet obtained with getResultSet. There are no more results when (!getMoreResults() && (getUpdateCount() == -1)
  Specified by:
    `getMoreResults` in interface `Statement`
  Returns:
    true if the next result is a ResultSet; false if it is an update count or there are no more results
  Throws:
    `SQLException` - if a database-access error occurs.
  See Also:
    `execute(java.lang.String)`

### getMaxFieldSize

    public int getMaxFieldSize()
                        throws SQLException

  The maxFieldSize limit (in bytes) is the maximum amount of data returned for any column value; it only applies to BINARY, VARBINARY, LONGVARBINARY, CHAR, VARCHAR, and LONGVARCHAR columns. If the limit is exceeded, the excess data is silently discarded.
  Specified by:
    `getMaxFieldSize` in interface `Statement`
  Returns:
    the current max column size limit; zero means unlimited
  Throws:
    `SQLException` - if a database-access error occurs.

### setMaxFieldSize

    public void setMaxFieldSize(int max)
                         throws SQLException

  The maxFieldSize limit (in bytes) is set to limit the size of data that can be returned for any column value; it only applies to BINARY, VARBINARY, LONGVARBINARY, CHAR, VARCHAR, and LONGVARCHAR fields. If the limit is exceeded, the excess data is silently discarded. For maximum portability use values greater than 256.
  Specified by:
    `setMaxFieldSize` in interface `Statement`
  Parameters:
    `max` - the new max column size limit; zero means unlimited
  Throws:
    `SQLException` - if a database-access error occurs.

### getMaxRows

    public int getMaxRows()
                   throws SQLException

  The maxRows limit is the maximum number of rows that a ResultSet can contain. If the limit is exceeded, the excess rows are silently dropped.
  Specified by:
    `getMaxRows` in interface `Statement`
  Returns:
    the current max row limit; zero means unlimited
  Throws:
    `SQLException` - if a database-access error occurs.

### setMaxRows

    public void setMaxRows(int max)
                    throws SQLException

  The maxRows limit is set to limit the number of rows that any ResultSet can contain. If the limit is exceeded, the excess rows are silently dropped.
  Specified by:
    `setMaxRows` in interface `Statement`
  Parameters:
    `max` - the new max rows limit; zero means unlimited
  Throws:
    `SQLException` - if a database-access error occurs.

### setEscapeProcessing

    public void setEscapeProcessing(boolean enable)
                             throws SQLException

  If escape scanning is on (the default), the driver will do escape substitution before sending the SQL to the database. Note: Since prepared statements have usually been parsed prior to making this call, disabling escape processing for prepared statements will like have no affect.
  Specified by:
    `setEscapeProcessing` in interface `Statement`
  Parameters:
    `enable` - true to enable; false to disable
  Throws:
    `SQLException` - if a database-access error occurs.

### getQueryTimeout

    public int getQueryTimeout()
                        throws SQLException

  The queryTimeout limit is the number of seconds the driver will wait for a Statement to execute. If the limit is exceeded, a SQLException is thrown.
  Specified by:
    `getQueryTimeout` in interface `Statement`
  Returns:
    the current query timeout limit in seconds; zero means unlimited
  Throws:
    `SQLException` - if a database-access error occurs.

### setQueryTimeout

    public void setQueryTimeout(int seconds)
                         throws SQLException

  The queryTimeout limit is the number of seconds the driver will wait for a Statement to execute. If the limit is exceeded, a SQLException is thrown.
  Specified by:
    `setQueryTimeout` in interface `Statement`
  Parameters:
    `seconds` - the new query timeout limit in seconds; zero means unlimited
  Throws:
    `SQLException` - if a database-access error occurs.

### cancel

    public void cancel()
                throws SQLException

  Cancel can be used by one thread to cancel a statement that is being executed by another thread.
  Specified by:
    `cancel` in interface `Statement`
  Throws:
    `SQLException` - if a database-access error occurs.

### getWarnings

    public SQLWarning getWarnings()
                           throws SQLException

  The first warning reported by calls on this Statement is returned. A Statment's execute methods clear its SQLWarning chain. Subsequent Statement warnings will be chained to this SQLWarning.

  The warning chain is automatically cleared each time a statement is (re)executed.

  Note: If you are processing a ResultSet then any warnings associated with ResultSet reads will be chained on the ResultSet object.

  Specified by:
    `getWarnings` in interface `Statement`
  Returns:
    the first SQLWarning or null
  Throws:
    `SQLException` - if a database-access error occurs.

### clearWarnings

    public void clearWarnings()
                       throws SQLException

  After this call, getWarnings returns null until a new warning is reported for this Statement.
  Specified by:
    `clearWarnings` in interface `Statement`
  Throws:
    `SQLException` - if a database-access error occurs.

### setCursorName

    public void setCursorName(String name)
                       throws SQLException

  setCursorname defines the SQL cursor name that will be used by subsequent Statement execute methods. This name can then be used in SQL positioned update/delete statements to identify the current row in the ResultSet generated by this statement. If the database doesn't support positioned update/delete, this method is a noop. To insure that a cursor has the proper isolation level to support update, the cursor's select statement should be of the form 'select for update ...'. If the 'for update' clause is omitted the positioned updates may fail.

  Note: By definition, positioned update/delete execution must be done by a different Statement than the one which generated the ResultSet being used for positioning. Also, cursor names must be unique within a Connection.

  Specified by:
    `setCursorName` in interface `Statement`
  Parameters:
    `name` - the new cursor name.
  Throws:
    `SQLException` - if a database-access error occurs.

### setFetchDirection

    public void setFetchDirection(int direction)
                           throws SQLException

  Give a hint as to the direction in which the rows in a result set will be processed. The hint applies only to result sets created using this Statement object. The default value is ResultSet.FETCH_FORWARD.
  Specified by:
    `setFetchDirection` in interface `Statement`
  Parameters:
    `direction` - the initial direction for processing rows
  Throws:
    `SQLException` - if a database-access error occurs or direction is not one of ResultSet.FETCH_FORWARD, ResultSet.FETCH_REVERSE, or ResultSet.FETCH_UNKNOWN

### getFetchDirection

    public int getFetchDirection()
                          throws SQLException

  Determine the fetch direction.
  Specified by:
    `getFetchDirection` in interface `Statement`
  Returns:
    the default fetch direction
  Throws:
    `SQLException` - if a database-access error occurs

### setFetchSize

    public void setFetchSize(int rows)
                      throws SQLException

  Give the JDBC driver a hint as to the number of rows that should be fetched from the database when more rows are needed. The number of rows specified only affects result sets created using this statement. If the value specified is zero, then the hint is ignored. The default value is zero.
  Specified by:
    `setFetchSize` in interface `Statement`
  Parameters:
    `rows` - the number of rows to fetch
  Throws:
    `SQLException` - if a database-access error occurs, or the condition 0 <= rows <= this.getMaxRows() is not satisfied.

### getFetchSize

    public int getFetchSize()
                     throws SQLException

  Determine the default fetch size.
  Specified by:
    `getFetchSize` in interface `Statement`

### getResultSetConcurrency

    public int getResultSetConcurrency()
                                throws SQLException

  Determine the result set concurrency.
  Specified by:
    `getResultSetConcurrency` in interface `Statement`

### getResultSetType

    public int getResultSetType()
                         throws SQLException

  Determine the result set type.
  Specified by:
    `getResultSetType` in interface `Statement`

### addBatch

    public void addBatch(String sql)
                  throws SQLException

  Adds a SQL command to the current batch of commmands for the statement. This method is optional.
  Specified by:
    `addBatch` in interface `Statement`
  Parameters:
    `sql` - typically this is a static SQL INSERT or UPDATE statement
  Throws:
    `SQLException` - if a database-access error occurs, or the driver does not support batch statements

### 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`
  Throws:
    `SQLException` - if a database access error occurs
  Since:
    1.2
  See Also:
    `Statement.addBatch(java.lang.String)`, What Is in the JDBC 2.0 API

### clearBatch

    public void clearBatch()
                    throws SQLException

  Make the set of commands in the current batch empty. This method is optional.
  Specified by:
    `clearBatch` in interface `Statement`
  Throws:
    `SQLException` - if a database-access error occurs, or the driver does not support batch statements

### executeBatch

    public int[] executeBatch()
                       throws SQLException

  Submit a batch of commands to the database for execution. This method is optional.
  Specified by:
    `executeBatch` in interface `Statement`
  Returns:
    an array of update counts containing one element for each command in the batch. The array is ordered according to the order in which commands were inserted into the batch
  Throws:
    `SQLException` - if a database-access error occurs, or the driver does not support batch statements

### getConnection

    public Connection getConnection()
                             throws SQLException

  Return the Connection that produced the Statement.
  Specified by:
    `getConnection` in interface `Statement`

### toString

    public String toString()

  Query as parsed.
  Overrides:
    `toString` in class `Object`

### clearParameters

    public void clearParameters()
                         throws SQLException

  Clears the current parameter values immediately.

  In general, parameter values remain in force for repeated use 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 the method `clearParameters`.

  Specified by:
    `clearParameters` in interface `PreparedStatement`
  Throws:
    `SQLException` - if a database access error occurs

### setObject

    public void setObject(int parameterIndex,
                          Object x,
                          int targetSqlType,
                          int scale)
                   throws SQLException

  Sets the value of the designated parameter with the given object. The second argument must be an object type; for integral values, the `java.lang` equivalent objects should be used.

  The given Java object will be converted to the given targetSqlType before being sent to the database. If the object has a custom mapping (is of a class implementing the interface `SQLData`), the JDBC driver should call the method `SQLData.writeSQL` to write it to the SQL data stream. If, on the other hand, the object is of a class implementing Ref, Blob, Clob, Struct, or Array, the driver should pass it to the database as a value of the corresponding SQL type.

  Note that this method may be used to pass datatabase- specific abstract data types.

  Specified by:
    `setObject` in interface `PreparedStatement`
  Parameters:
    `parameterIndex` - the first parameter is 1, the second is 2, ...
    `x` - the object containing the input parameter value
    `targetSqlType` - the SQL type (as defined in java.sql.Types) to be sent to the database. The scale argument may further qualify this type.
    `scale` - for java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types, this is the number of digits after the decimal point. For all other types, this value will be ignored.
  Throws:
    `SQLException` - if a database access error occurs
  See Also:
    `Types`

### setObject

    public void setObject(int parameterIndex,
                          Object x,
                          int targetSqlType)
                   throws SQLException

  Sets the value of the designated parameter with the given object. This method is like the method `setObject` above, except that it assumes a scale of zero.
  Specified by:
    `setObject` in interface `PreparedStatement`
  Parameters:
    `parameterIndex` - the first parameter is 1, the second is 2, ...
    `x` - the object containing the input parameter value
    `targetSqlType` - the SQL type (as defined in java.sql.Types) to be sent to the database
  Throws:
    `SQLException` - if a database access error occurs

### setObject

    public void setObject(int parameterIndex,
                          Object x)
                   throws SQLException

  Sets the value of the designated parameter using the given object. The second parameter must be of type `Object`; therefore, the `java.lang` equivalent objects should be used for built-in types.

  The JDBC specification specifies a standard mapping from Java `Object` types to SQL types. The given argument will be converted to the corresponding SQL type before being sent to the database.

  Note that this method may be used to pass datatabase- specific abstract data types, by using a driver-specific Java type. If the object is of a class implementing the interface `SQLData`, the JDBC driver should call the method `SQLData.writeSQL` to write it to the SQL data stream. If, on the other hand, the object is of a class implementing Ref, Blob, Clob, Struct, or Array, then the driver should pass it to the database as a value of the corresponding SQL type. This method throws an exception if there is an ambiguity, for example, if the object is of a class implementing more than one of the interfaces named above.

  Specified by:
    `setObject` in interface `PreparedStatement`
  Parameters:
    `parameterIndex` - the first parameter is 1, the second is 2, ...
    `x` - the object containing the input parameter value
  Throws:
    `SQLException` - if a database access error occurs

### setNull

    public void setNull(int parameterIndex,
                        int sqlType)
                 throws SQLException

  Sets the designated parameter to SQL `NULL`.

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

  Specified by:
    `setNull` in interface `PreparedStatement`
  Parameters:
    `parameterIndex` - the first parameter is 1, the second is 2, ...
    `sqlType` - the SQL type code defined in `java.sql.Types`
  Throws:
    `SQLException` - if a database access error occurs

### setBoolean

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

  Sets the designated parameter to a Java `boolean` value. The driver converts this to an SQL `BIT` value when it sends it to the database.
  Specified by:
    `setBoolean` in interface `PreparedStatement`
  Parameters:
    `parameterIndex` - the first parameter is 1, the second is 2, ...
    `x` - the parameter value
  Throws:
    `SQLException` - if a database access error occurs

### setByte

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

  Sets the designated parameter to a Java `byte` value. The driver converts this to an SQL `TINYINT` value when it sends it to the database.
  Specified by:
    `setByte` in interface `PreparedStatement`
  Parameters:
    `parameterIndex` - the first parameter is 1, the second is 2, ...
    `x` - the parameter value
  Throws:
    `SQLException` - if a database access error occurs

### setShort

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

  Sets the designated parameter to a Java `short` value. The driver converts this to an SQL `SMALLINT` value when it sends it to the database.
  Specified by:
    `setShort` in interface `PreparedStatement`
  Parameters:
    `parameterIndex` - the first parameter is 1, the second is 2, ...
    `x` - the parameter value
  Throws:
    `SQLException` - if a database access error occurs

### setInt

    public void setInt(int parameterIndex,
                       int x)
                throws SQLException

  Sets the designated parameter to a Java `int` value. The driver converts this to an SQL `INTEGER` value when it sends it to the database.
  Specified by:
    `setInt` in interface `PreparedStatement`
  Parameters:
    `parameterIndex` - the first parameter is 1, the second is 2, ...
    `x` - the parameter value
  Throws:
    `SQLException` - if a database access error occurs

### setLong

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

  Sets the designated parameter to a Java `long` value. The driver converts this to an SQL `BIGINT` value when it sends it to the database.
  Specified by:
    `setLong` in interface `PreparedStatement`
  Parameters:
    `parameterIndex` - the first parameter is 1, the second is 2, ...
    `x` - the parameter value
  Throws:
    `SQLException` - if a database access error occurs

### setFloat

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

  Sets the designated parameter to a Java `float` value. The driver converts this to an SQL `FLOAT` value when it sends it to the database.
  Specified by:
    `setFloat` in interface `PreparedStatement`
  Parameters:
    `parameterIndex` - the first parameter is 1, the second is 2, ...
    `x` - the parameter value
  Throws:
    `SQLException` - if a database access error occurs

### setDouble

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

  Sets the designated parameter to a Java `double` value. The driver converts this to an SQL `DOUBLE` value when it sends it to the database.
  Specified by:
    `setDouble` in interface `PreparedStatement`
  Parameters:
    `parameterIndex` - the first parameter is 1, the second is 2, ...
    `x` - the parameter value
  Throws:
    `SQLException` - if a database access error occurs

### setBigDecimal

    public void setBigDecimal(int parameterIndex,
                              BigDecimal x)
                       throws SQLException

  Sets the designated parameter to a `java.math.BigDecimal` value. The driver converts this to an SQL `NUMERIC` value when it sends it to the database.
  Specified by:
    `setBigDecimal` in interface `PreparedStatement`
  Parameters:
    `parameterIndex` - the first parameter is 1, the second is 2, ...
    `x` - the parameter value
  Throws:
    `SQLException` - if a database access error occurs

### setString

    public void setString(int parameterIndex,
                          String x)
                   throws SQLException

  Sets the designated parameter to a Java `String` value. The driver converts this to an SQL `VARCHAR` or `LONGVARCHAR` value (depending on the argument's size relative to the driver's limits on `VARCHAR` values) when it sends it to the database.
  Specified by:
    `setString` in interface `PreparedStatement`
  Parameters:
    `parameterIndex` - the first parameter is 1, the second is 2, ...
    `x` - the parameter value
  Throws:
    `SQLException` - if a database access error occurs

### setBytes

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

  Sets the designated parameter to a Java array of bytes. The driver converts this to an SQL `VARBINARY` or `LONGVARBINARY` (depending on the argument's size relative to the driver's limits on `VARBINARY` values) when it sends it to the database.
  Specified by:
    `setBytes` in interface `PreparedStatement`
  Parameters:
    `parameterIndex` - the first parameter is 1, the second is 2, ...
    `x` - the parameter value
  Throws:
    `SQLException` - if a database access error occurs

### setDate

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

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

### setTime

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

  Sets the designated parameter to a `java.sql.Time` value. The driver converts this to an SQL `TIME` value when it sends it to the database.
  Specified by:
    `setTime` in interface `PreparedStatement`
  Parameters:
    `parameterIndex` - the first parameter is 1, the second is 2, ...
    `x` - the parameter value
  Throws:
    `SQLException` - if a database access error occurs

### setTimestamp

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

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

### setAsciiStream

    public void setAsciiStream(int parameterIndex,
                               InputStream x,
                               int length)
                        throws SQLException

  Sets the designated parameter to the given input stream, which will have the specified number of bytes. 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`. Data will be read from the stream as needed until end-of-file is reached. 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 `PreparedStatement`
  Parameters:
    `parameterIndex` - the first parameter is 1, the second is 2, ...
    `x` - the Java input stream that contains the ASCII parameter value
    `length` - the number of bytes in the stream
  Throws:
    `SQLException` - if a database access error occurs

### setUnicodeStream

    public void setUnicodeStream(int parameterIndex,
                                 InputStream x,
                                 int length)
                          throws SQLException

  Deprecated.

  Sets the designated parameter to the given input stream, which will have the specified number of bytes. 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` object. The data will be read from the stream as needed until end-of-file is reached. The JDBC driver will do any necessary conversion from UNICODE to the database char format. The byte format of the Unicode stream must be Java UTF-8, as defined in the Java Virtual Machine Specification.

  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 `PreparedStatement`
  Parameters:
    `parameterIndex` - the first parameter is 1, the second is 2, ...
    `x` - the java input stream which contains the UNICODE parameter value
    `length` - the number of bytes in the stream
  Throws:
    `SQLException` - if a database access error occurs

### setBinaryStream

    public void setBinaryStream(int parameterIndex,
                                InputStream x,
                                int length)
                         throws SQLException

  Sets the designated parameter to the given input stream, which will have the specified number of bytes. 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` object. The data will be read from the stream as needed until end-of-file is reached.

  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 `PreparedStatement`
  Parameters:
    `parameterIndex` - the first parameter is 1, the second is 2, ...
    `x` - the java input stream which contains the binary parameter value
    `length` - the number of bytes in the stream
  Throws:
    `SQLException` - if a database access error occurs

### setCharacterStream

    public void setCharacterStream(int parameterIndex,
                                   Reader reader,
                                   int length)
                            throws SQLException

  Sets the designated parameter to the given `Reader` object, which is the given number of characters long. 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` object. The data will be read from the stream as needed until end-of-file is reached. 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 `PreparedStatement`
  Parameters:
    `parameterIndex` - the first parameter is 1, the second is 2, ...
    `x` - the java reader which contains the UNICODE data
    `length` - the number of characters in the stream
  Throws:
    `SQLException` - if a database access error occurs
  Since:
    1.2
  See Also:
    What Is in the JDBC 2.0 API

### setRef

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

  Sets the designated parameter to the given `REF(<structured-type>)` value.
  Specified by:
    `setRef` in interface `PreparedStatement`
  Parameters:
    `i` - the first parameter is 1, the second is 2, ...
    `x` - an SQL `REF` value
  Throws:
    `SQLException` - if a database access error occurs
  Since:
    1.2
  See Also:
    What Is in the JDBC 2.0 API

### setBlob

    public void setBlob(int i,
                        Blob x)
                 throws SQLException

  Sets the designated parameter to the given `Blob` object.
  Specified by:
    `setBlob` in interface `PreparedStatement`
  Parameters:
    `i` - the first parameter is 1, the second is 2, ...
    `x` - a `Blob` object that maps an SQL `BLOB` value
  Throws:
    `SQLException` - if a database access error occurs
  Since:
    1.2
  See Also:
    What Is in the JDBC 2.0 API

### setClob

    public void setClob(int i,
                        Clob x)
                 throws SQLException

  Sets the designated parameter to the given `Clob` object.
  Specified by:
    `setClob` in interface `PreparedStatement`
  Parameters:
    `i` - the first parameter is 1, the second is 2, ...
    `x` - a `Clob` object that maps an SQL `CLOB` value
  Throws:
    `SQLException` - if a database access error occurs
  Since:
    1.2
  See Also:
    What Is in the JDBC 2.0 API

### setArray

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

  Sets the designated parameter to the given `Array` object. Sets an Array parameter.
  Specified by:
    `setArray` in interface `PreparedStatement`
  Parameters:
    `i` - the first parameter is 1, the second is 2, ...
    `x` - an `Array` object that maps an SQL `ARRAY` value
  Throws:
    `SQLException` - if a database access error occurs
  Since:
    1.2
  See Also:
    What Is in the JDBC 2.0 API

### setDate

    public void setDate(int parameterIndex,
                        Date x,
                        Calendar cal)
                 throws SQLException

  Sets the designated parameter to the given `java.sql.Date` value, using the given `Calendar` object. The driver uses the `Calendar` object to construct an SQL `DATE` value, which the driver then sends to the database. With a a `Calendar` object, the driver can calculate the date taking into account a custom timezone. If no `Calendar` object is specified, the driver uses the default timezone, which is that of the virtual machine running the application.
  Specified by:
    `setDate` in interface `PreparedStatement`
  Parameters:
    `parameterIndex` - the first parameter is 1, the second is 2, ...
    `x` - the parameter value
    `cal` - the `Calendar` object the driver will use to construct the date
  Throws:
    `SQLException` - if a database access error occurs
  Since:
    1.2
  See Also:
    What Is in the JDBC 2.0 API

### setTime

    public void setTime(int parameterIndex,
                        Time x,
                        Calendar cal)
                 throws SQLException

  Sets the designated parameter to the given `java.sql.Time` value, using the given `Calendar` object. The driver uses the `Calendar` object to construct an SQL `TIME` value, which the driver then sends to the database. With a a `Calendar` object, the driver can calculate the time taking into account a custom timezone. If no `Calendar` object is specified, the driver uses the default timezone, which is that of the virtual machine running the application.
  Specified by:
    `setTime` in interface `PreparedStatement`
  Parameters:
    `parameterIndex` - the first parameter is 1, the second is 2, ...
    `x` - the parameter value
    `cal` - the `Calendar` object the driver will use to construct the time
  Throws:
    `SQLException` - if a database access error occurs
  Since:
    1.2
  See Also:
    What Is in the JDBC 2.0 API

### setTimestamp

    public void setTimestamp(int parameterIndex,
                             Timestamp x,
                             Calendar cal)
                      throws SQLException

  Sets the designated parameter to the given `java.sql.Timestamp` value, using the given `Calendar` object. The driver uses the `Calendar` object to construct an SQL `TIMESTAMP` value, which the driver then sends to the database. With a a `Calendar` object, the driver can calculate the timestamp taking into account a custom timezone. If no `Calendar` object is specified, the driver uses the default timezone, which is that of the virtual machine running the application.
  Specified by:
    `setTimestamp` in interface `PreparedStatement`
  Parameters:
    `parameterIndex` - the first parameter is 1, the second is 2, ...
    `x` - the parameter value
    `cal` - the `Calendar` object the driver will use to construct the timestamp
  Throws:
    `SQLException` - if a database access error occurs
  Since:
    1.2
  See Also:
    What Is in the JDBC 2.0 API

### setNull

    public void setNull(int paramIndex,
                        int sqlType,
                        String typeName)
                 throws SQLException

  Sets the designated parameter to SQL `NULL`. This version of the method `setNull` should be used for user-defined types and REF type parameters. Examples of user-defined types include: STRUCT, DISTINCT, JAVA_OBJECT, and named array types.

  Note: To be portable, applications must give the SQL type code and the fully-qualified SQL type name when specifying a NULL user-defined or REF parameter. In the case of a user-defined type the name is the type name of the parameter itself. For a REF parameter, the name is the type name of the referenced type. If a JDBC driver does not need the type code or type name information, it may ignore it. Although it is intended for user-defined and Ref parameters, this method may be used to set a null parameter of any JDBC type. If the parameter does not have a user-defined or REF type, the given typeName is ignored.

  Specified by:
    `setNull` in interface `PreparedStatement`
  Parameters:
    `parameterIndex` - the first parameter is 1, the second is 2, ...
    `sqlType` - a value from `java.sql.Types`
    `typeName` - the fully-qualified name of an SQL user-defined type; ignored if the parameter is not a user-defined type or REF
  Throws:
    `SQLException` - if a database access error occurs
  Since:
    1.2
  See Also:
    What Is in the JDBC 2.0 API

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD