Package virtuoso.jdbc4

## Class VirtuosoPreparedStatement

- java.lang.Object
- - virtuoso.jdbc4.VirtuosoStatement
  - - virtuoso.jdbc4.VirtuosoPreparedStatement

All Implemented Interfaces:
  `java.lang.AutoCloseable`, `java.sql.PreparedStatement`, `java.sql.Statement`, `java.sql.Wrapper`

Direct Known Subclasses:
  `VirtuosoCallableStatement`

    public class VirtuosoPreparedStatement
    extends VirtuosoStatement
    implements java.sql.PreparedStatement

The VirtuosoPreparedStatement class is an implementation of the PreparedStatement interface in the JDBC API which represents a prepared statement. You can obtain a Statement like below :

       PreparedStatement s = connection.prepareStatement(...)

See Also:
  `VirtuosoConnection.prepareStatement(java.lang.String)`

### Field Summary

Fields
`protected VirtuosoResultSet` `ps_vresultSet`
`protected java.lang.String` `sql`

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

### Fields inherited from class virtuoso.jdbc4.VirtuosoStatement

`batch, close_flag, closeOnCompletion, connection, cursorName, exec_type, future, isCached, metaData, objparams, parameters, paramsMetaData, prefetch, req_no, result_opened, rpc_timeout, sparql_executed, statid, txn_timeout, type, vresultSet, wait_result`

### Method Summary

All Methods Instance Methods Concrete Methods
`void` `addBatch​()` Adds a set of parameters to the batch.
`void` `clearParameters​()` Clears the current parameter values immediately.
`void` `close​()` Releases this Statement object's database and JDBC resources immediately instead of new wait for this to happen when it is automatically closed.
`boolean` `execute​()` Executes any kind of SQL statement.
`int[]` `executeBatch​()` Submits a batch of commands to the database for execution.
`int[]` `executeBatchUpdate​()`
`java.sql.ResultSet` `executeQuery​()` Executes a SQL prepare statement that returns a single ResultSet.
`int` `executeUpdate​()` Executes the SQL INSERT, UPDATE or DELETE statement in this PreparedStatement object.
`void` `finalize​()` Method runs when the garbage collector want to erase the object
`java.sql.ResultSetMetaData` `getMetaData​()` Gets the number, types and properties of a ResultSet's columns.
`java.sql.ParameterMetaData` `getParameterMetaData​()` Retrieves the number, types and properties of this `PreparedStatement` object's parameters.
`void` `setArray​(int i, java.sql.Array x)` Sets an Array parameter.
`void` `setAsciiStream​(int parameterIndex, java.io.InputStream x)` Sets the designated parameter to the given input stream.
`void` `setAsciiStream​(int parameterIndex, java.io.InputStream x, int length)` Sets the designated parameter to the given input stream, which will have the specified number of bytes.
`void` `setAsciiStream​(int parameterIndex, java.io.InputStream x, long length)` Sets the designated parameter to the given input stream, which will have the specified number of bytes.
`void` `setBigDecimal​(int parameterIndex, java.math.BigDecimal x)` Sets the designated parameter to a java.lang.BigDecimal value.
`void` `setBinaryStream​(int parameterIndex, java.io.InputStream x)` Sets the designated parameter to the given input stream.
`void` `setBinaryStream​(int parameterIndex, java.io.InputStream x, int length)` Sets the designated parameter to the given input stream, which will have the specified number of bytes.
`void` `setBinaryStream​(int parameterIndex, java.io.InputStream x, long length)` Sets the designated parameter to the given input stream, which will have the specified number of bytes.
`void` `setBlob​(int parameterIndex, java.io.InputStream inputStream)` Sets the designated parameter to a `InputStream` object.
`void` `setBlob​(int parameterIndex, java.io.InputStream inputStream, long length)` Sets the designated parameter to a `InputStream` object.
`void` `setBlob​(int i, java.sql.Blob x)` Sets a BLOB parameter.
`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, java.io.Reader reader)` Sets the designated parameter to the given `Reader` object.
`void` `setCharacterStream​(int parameterIndex, java.io.Reader x, int length)` Sets the designated parameter to the given `Reader` object, which is the given number of characters long.
`void` `setCharacterStream​(int parameterIndex, java.io.Reader reader, long length)` Sets the designated parameter to the given `Reader` object, which is the given number of characters long.
`void` `setClob​(int parameterIndex, java.io.Reader reader)` Sets the designated parameter to a `Reader` object.
`void` `setClob​(int parameterIndex, java.io.Reader reader, long length)` Sets the designated parameter to a `Reader` object.
`void` `setClob​(int i, java.sql.Clob x)` Sets a CLOB parameter.
`protected void` `setClosed​(boolean flag)`
`void` `setDate​(int parameterIndex, java.sql.Date x)` Sets the designated parameter to a java.sql.Date value.
`void` `setDate​(int parameterIndex, java.sql.Date x, java.util.Calendar cal)` Sets the designated parameter to a 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` `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` `setNCharacterStream​(int parameterIndex, java.io.Reader value)` Sets the designated parameter to a `Reader` object.
`void` `setNCharacterStream​(int parameterIndex, java.io.Reader value, long length)` Sets the designated parameter to a `Reader` object.
`void` `setNClob​(int parameterIndex, java.io.Reader reader)` Sets the designated parameter to a `Reader` object.
`void` `setNClob​(int parameterIndex, java.io.Reader reader, long length)` Sets the designated parameter to a `Reader` object.
`void` `setNClob​(int parameterIndex, java.sql.NClob value)` Sets the designated parameter to a `java.sql.NClob` object.
`void` `setNString​(int parameterIndex, java.lang.String value)` Sets the designated paramter to the given `String` object.
`void` `setNull​(int parameterIndex, int sqlType)` Sets the designated parameter to SQL NULL.
`void` `setNull​(int paramIndex, int sqlType, java.lang.String typeName)` Sets the designated parameter to SQL NULL.
`void` `setObject​(int parameterIndex, java.lang.Object x)` Sets the value of a parameter using an object; use the java.lang equivalent objects for integral values.
`void` `setObject​(int parameterIndex, java.lang.Object x, int targetSqlType)` Sets the value of the designated parameter with the given object.
`void` `setObject​(int parameterIndex, java.lang.Object x, int targetSqlType, int scale)` Sets the value of a parameter using an object.
`void` `setRef​(int i, java.sql.Ref x)` Sets a REF(<structured-type>) parameter.
`void` `setRowId​(int parameterIndex, java.sql.RowId x)` Sets the designated parameter to the given `java.sql.RowId` object.
`void` `setShort​(int parameterIndex, short x)` Sets the designated parameter to a Java short value.
`void` `setSQLXML​(int parameterIndex, java.sql.SQLXML xmlObject)` Sets the designated parameter to the given `java.sql.SQLXML` object.
`void` `setString​(int parameterIndex, java.lang.String x)` Sets the designated parameter to a Java String value.
`protected void` `setString​(int parameterIndex, VirtuosoExplicitString x)`
`void` `setTime​(int parameterIndex, java.sql.Time x)` Sets the designated parameter to a java.sql.Time value.
`void` `setTime​(int parameterIndex, java.sql.Time x, java.util.Calendar cal)` Sets the designated parameter to a java.sql.Time value, using the given Calendar object.
`void` `setTimestamp​(int parameterIndex, java.sql.Timestamp x)` Sets the designated parameter to a java.sql.Timestamp value.
`void` `setTimestamp​(int parameterIndex, java.sql.Timestamp x, java.util.Calendar cal)` Sets the designated parameter to a java.sql.Timestamp value, using the given Calendar object.
`void` `setUnicodeStream​(int parameterIndex, java.io.InputStream x, int length)` Sets the designated parameter to the given input stream, which will have the specified number of unicode chars.
`void` `setURL​(int parameterIndex, java.net.URL x)` Sets the designated parameter to the given `java.net.URL` value.
`protected void` `setVector​(int parameterIndex, Vector x)` Sets the designated parameter to a Java Vector value.

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

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

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

`executeLargeUpdate, setObject, setObject`

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

`addBatch, cancel, clearBatch, clearWarnings, closeOnCompletion, enquoteIdentifier, enquoteLiteral, enquoteNCharLiteral, execute, execute, execute, execute, executeLargeBatch, executeLargeUpdate, executeLargeUpdate, executeLargeUpdate, executeLargeUpdate, executeQuery, executeUpdate, executeUpdate, executeUpdate, executeUpdate, 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, setLargeMaxRows, setMaxFieldSize, setMaxRows, setPoolable, setQueryTimeout`

### Methods inherited from class virtuoso.jdbc4.VirtuosoStatement

`addBatch, cancel, cancel_rs, clearBatch, clearWarnings, close_rs, closeOnCompletion, execute, execute, execute, execute, executeQuery, executeUpdate, executeUpdate, executeUpdate, executeUpdate, getConnection, getExecType, getFetchDirection, getFetchSize, getGeneratedKeys, getMaxFieldSize, getMaxRows, getMoreResults, getMoreResults, getQueryTimeout, getResultSet, getResultSetConcurrency, getResultSetHoldability, getResultSetType, getStmtOpts, getUpdateCount, getWarnings, isClosed, isCloseOnCompletion, isPoolable, isWrapperFor, notify_error, sendQuery, setCursorName, setEscapeProcessing, setFetchDirection, setFetchSize, setMaxFieldSize, setMaxRows, setPoolable, setQueryTimeout, unwrap`

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

`isWrapperFor, unwrap`

### Field Detail

#### sql

    protected java.lang.String sql

#### ps_vresultSet

    protected VirtuosoResultSet ps_vresultSet

### Method Detail

#### setVector

    protected void setVector​(int parameterIndex,
                             Vector x)
                      throws VirtuosoException

Sets the designated parameter to a Java Vector value.

Parameters:
  `parameterIndex` - the first parameter is 1, the second is 2, ...
  `x` - the parameter value
Throws:
  `VirtuosoException` - if a database access error occurs

#### clearParameters

    public void clearParameters​()
                         throws VirtuosoException

Clears the current parameter values immediately.

Specified by:
  `clearParameters` in interface `java.sql.PreparedStatement`
Throws:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.clearParameters()`

#### execute

    public boolean execute​()
                    throws VirtuosoException

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 executeQuery and executeUpdate.

Specified by:
  `execute` in interface `java.sql.PreparedStatement`
Throws:
  `VirtuosoException` - If a database access error occurs.
See Also:
  `VirtuosoStatement.getResultSet()`, `VirtuosoStatement.getUpdateCount()`, `VirtuosoStatement.getMoreResults()`, `PreparedStatement.execute()`

#### executeUpdate

    public int executeUpdate​()
                      throws VirtuosoException

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 `java.sql.PreparedStatement`
Returns:
  either the row count for INSERT, UPDATE or DELETE statements; or 0 for SQL statements that return nothing
Throws:
  `VirtuosoException` - If a database access error occurs.
See Also:
  `PreparedStatement.executeUpdate()`

#### executeBatchUpdate

    public int[] executeBatchUpdate​()
                             throws java.sql.BatchUpdateException

Throws:
  `java.sql.BatchUpdateException`

#### executeQuery

    public java.sql.ResultSet executeQuery​()
                                    throws VirtuosoException

Executes a SQL prepare statement that returns a single ResultSet.

Specified by:
  `executeQuery` in interface `java.sql.PreparedStatement`
Returns:
  ResultSet A ResultSet that contains the data produced by the query; never null.
Throws:
  `VirtuosoException` - If a database access error occurs.
See Also:
  `PreparedStatement.executeQuery()`

#### getMetaData

    public java.sql.ResultSetMetaData getMetaData​()
                                           throws VirtuosoException

Gets the number, types and properties of a ResultSet's columns.

Specified by:
  `getMetaData` in interface `java.sql.PreparedStatement`
Returns:
  the description of a ResultSet's columns
Throws:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.getMetaData()`

#### finalize

    public void finalize​()
                  throws java.lang.Throwable

Method runs when the garbage collector want to erase the object

Overrides:
  `finalize` in class `VirtuosoStatement`
Throws:
  `java.lang.Throwable`

#### close

    public void close​()
               throws VirtuosoException

Releases this Statement object's database and JDBC resources immediately instead of new wait for this to happen when it is automatically closed.

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

#### setAsciiStream

    public void setAsciiStream​(int parameterIndex,
                               java.io.InputStream x,
                               int length)
                        throws VirtuosoException

Sets the designated parameter to the given input stream, which will have the specified number of bytes.

Specified by:
  `setAsciiStream` in interface `java.sql.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:
  `VirtuosoException` - 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 VirtuosoException

Sets the designated parameter to a java.lang.BigDecimal value. The driver converts this to an SQL NUMERIC value when it sends it to the database.

Specified by:
  `setBigDecimal` in interface `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - the first parameter is 1, the second is 2, ...
  `x` - the parameter value
Throws:
  `VirtuosoException` - 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 VirtuosoException

Sets the designated parameter to the given input stream, which will have the specified number of bytes.

Specified by:
  `setBinaryStream` in interface `java.sql.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:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.setBinaryStream(int, java.io.InputStream, int)`

#### setUnicodeStream

    public void setUnicodeStream​(int parameterIndex,
                                 java.io.InputStream x,
                                 int length)
                          throws VirtuosoException

Sets the designated parameter to the given input stream, which will have the specified number of unicode chars.

Specified by:
  `setUnicodeStream` in interface `java.sql.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:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.setBinaryStream(int, java.io.InputStream, int)`

#### setBoolean

    public void setBoolean​(int parameterIndex,
                           boolean x)
                    throws VirtuosoException

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 `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - the first parameter is 1, the second is 2, ...
  `x` - the parameter value
Throws:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.setBoolean(int, boolean)`

#### setByte

    public void setByte​(int parameterIndex,
                        byte x)
                 throws VirtuosoException

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 `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - the first parameter is 1, the second is 2, ...
  `x` - the parameter value
Throws:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.setByte(int, byte)`

#### setBytes

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

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 VARBINARYs) when it sends it to the database.

Specified by:
  `setBytes` in interface `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - the first parameter is 1, the second is 2, ...
  `x` - the parameter value
Throws:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.setBytes(int, byte[])`

#### setDate

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

Sets the designated parameter to a java.sql.Date value. The driver converts this to an SQL DATE value when it sends it to the database.

Specified by:
  `setDate` in interface `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - the first parameter is 1, the second is 2, ...
  `x` - the parameter value
Throws:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.setDate(int, java.sql.Date)`

#### setDouble

    public void setDouble​(int parameterIndex,
                          double x)
                   throws VirtuosoException

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 `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - the first parameter is 1, the second is 2, ...
  `x` - the parameter value
Throws:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.setDouble(int, double)`

#### setFloat

    public void setFloat​(int parameterIndex,
                         float x)
                  throws VirtuosoException

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 `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - the first parameter is 1, the second is 2, ...
  `x` - the parameter value
Throws:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.setFloat(int, float)`

#### setInt

    public void setInt​(int parameterIndex,
                       int x)
                throws VirtuosoException

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 `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - the first parameter is 1, the second is 2, ...
  `x` - the parameter value
Throws:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.setInt(int, int)`

#### setLong

    public void setLong​(int parameterIndex,
                        long x)
                 throws VirtuosoException

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 `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - the first parameter is 1, the second is 2, ...
  `x` - the parameter value
Throws:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.setLong(int, long)`

#### setNull

    public void setNull​(int parameterIndex,
                        int sqlType)
                 throws VirtuosoException

Sets the designated parameter to SQL NULL. Note: You must specify the parameter's SQL type.

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

#### setObject

    public void setObject​(int parameterIndex,
                          java.lang.Object x)
                   throws VirtuosoException

Sets the value of a parameter using an object; use the java.lang equivalent objects for integral values.

Specified by:
  `setObject` in interface `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - the first parameter is 1, the second is 2, ...
  `x` - the object containing the input parameter value
Throws:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.setObject(int, java.lang.Object, int)`

#### setObject

    public void setObject​(int parameterIndex,
                          java.lang.Object x,
                          int targetSqlType)
                   throws VirtuosoException

Sets the value of the designated parameter with the given object. This method is like setObject above, except that it assumes a scale of zero.

Specified by:
  `setObject` in interface `java.sql.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:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.setObject(int, java.lang.Object, int)`

#### setObject

    public void setObject​(int parameterIndex,
                          java.lang.Object x,
                          int targetSqlType,
                          int scale)
                   throws VirtuosoException

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

Specified by:
  `setObject` in interface `java.sql.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:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.setObject(int, java.lang.Object, int)`, `Types`

#### setShort

    public void setShort​(int parameterIndex,
                         short x)
                  throws VirtuosoException

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 `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - the first parameter is 1, the second is 2, ...
  `x` - the parameter value
Throws:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.setShort(int, short)`

#### setString

    public void setString​(int parameterIndex,
                          java.lang.String x)
                   throws VirtuosoException

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 VARCHARs) when it sends it to the database.

Specified by:
  `setString` in interface `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - the first parameter is 1, the second is 2, ...
  `x` - the parameter value
Throws:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.setString(int, java.lang.String)`

#### setString

    protected void setString​(int parameterIndex,
                             VirtuosoExplicitString x)
                      throws VirtuosoException

Throws:
  `VirtuosoException`

#### setTime

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

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 `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - the first parameter is 1, the second is 2, ...
  `x` - the parameter value
Throws:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.setTime(int, java.sql.Time)`

#### setTimestamp

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

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 `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - the first parameter is 1, the second is 2, ...
  `x` - the parameter value
Throws:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.setTimestamp(int, java.sql.Timestamp)`

#### addBatch

    public void addBatch​()
                  throws VirtuosoException

Adds a set of parameters to the batch.

Specified by:
  `addBatch` in interface `java.sql.PreparedStatement`
Throws:
  `VirtuosoException` - If a database access error occurs.
See Also:
  `PreparedStatement.addBatch()`

#### executeBatch

    public int[] executeBatch​()
                       throws java.sql.BatchUpdateException

Description copied from class: `VirtuosoStatement`
Submits a batch of commands to the database for execution.

Specified by:
  `executeBatch` in interface `java.sql.Statement`
Overrides:
  `executeBatch` in class `VirtuosoStatement`
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:
  `java.sql.BatchUpdateException` - if a database access error occurs

#### setArray

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

Sets an Array parameter.

Specified by:
  `setArray` in interface `java.sql.PreparedStatement`
Parameters:
  `i` - the first parameter is 1, the second is 2, ...
  `x` - an object representing an SQL array
Throws:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.setArray(int, java.sql.Array)`

#### setBlob

    public void setBlob​(int i,
                        java.sql.Blob x)
                 throws VirtuosoException

Sets a BLOB parameter.

Specified by:
  `setBlob` in interface `java.sql.PreparedStatement`
Parameters:
  `i` - the first parameter is 1, the second is 2, ...
  `x` - an object representing a BLOB
Throws:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.setBlob(int, java.sql.Blob)`

#### setCharacterStream

    public void setCharacterStream​(int parameterIndex,
                                   java.io.Reader x,
                                   int length)
                            throws VirtuosoException

Sets the designated parameter to the given `Reader` object, which is the given number of characters long.

Specified by:
  `setCharacterStream` in interface `java.sql.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:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.setCharacterStream(int, java.io.Reader, int)`

#### setClob

    public void setClob​(int i,
                        java.sql.Clob x)
                 throws VirtuosoException

Sets a CLOB parameter.

Specified by:
  `setClob` in interface `java.sql.PreparedStatement`
Parameters:
  `i` - the first parameter is 1, the second is 2, ...
  `x` - an object representing a CLOB
Throws:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.setClob(int, java.sql.Clob)`

#### setNull

    public void setNull​(int paramIndex,
                        int sqlType,
                        java.lang.String typeName)
                 throws VirtuosoException

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

Specified by:
  `setNull` in interface `java.sql.PreparedStatement`
Parameters:
  `paramIndex` - 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-named type, ignored if the parameter is not a user-named type or REF
Throws:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.setNull(int, int)`

#### setRef

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

Sets a REF(<structured-type>) parameter.

Specified by:
  `setRef` in interface `java.sql.PreparedStatement`
Parameters:
  `i` - the first parameter is 1, the second is 2, ...
  `x` - an object representing data of an SQL REF Type
Throws:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.setRef(int, java.sql.Ref)`

#### setDate

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

Sets the designated parameter to a java.sql.Date value, using the given Calendar object.

Specified by:
  `setDate` in interface `java.sql.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:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.setDate(int, java.sql.Date)`

#### setTime

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

Sets the designated parameter to a java.sql.Time value, using the given Calendar object.

Specified by:
  `setTime` in interface `java.sql.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:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.setTime(int, java.sql.Time)`

#### setTimestamp

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

Sets the designated parameter to a java.sql.Timestamp value, using the given Calendar object.

Specified by:
  `setTimestamp` in interface `java.sql.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:
  `VirtuosoException` - if a database access error occurs
See Also:
  `PreparedStatement.setTimestamp(int, java.sql.Timestamp)`

#### setURL

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

Sets the designated parameter to the given `java.net.URL` value. The driver converts this to an SQL `DATALINK` value when it sends it to the database.

Specified by:
  `setURL` in interface `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - the first parameter is 1, the second is 2, ...
  `x` - the `java.net.URL` object to be set
Throws:
  `java.sql.SQLException` - if a database access error occurs
Since:
  1.4

#### getParameterMetaData

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

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

Specified by:
  `getParameterMetaData` in interface `java.sql.PreparedStatement`
Returns:
  a `ParameterMetaData` object that contains information about the number, types and properties of this `PreparedStatement` object's parameters
Throws:
  `java.sql.SQLException` - if a database access error occurs
Since:
  1.4
See Also:
  `ParameterMetaData`

#### setRowId

    public void setRowId​(int parameterIndex,
                         java.sql.RowId x)
                  throws java.sql.SQLException

Sets the designated parameter to the given `java.sql.RowId` object. The driver converts this to a SQL `ROWID` value when it sends it to the database

Specified by:
  `setRowId` in interface `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - the first parameter is 1, the second is 2, ...
  `x` - the parameter value
Throws:
  `java.sql.SQLException` - if parameterIndex does not correspond to a parameter marker in the SQL statement; if a database access error occurs or this method is called on a closed `PreparedStatement`
  `java.sql.SQLFeatureNotSupportedException` - if the JDBC driver does not support this method
Since:
  1.6

#### setNString

    public void setNString​(int parameterIndex,
                           java.lang.String value)
                    throws java.sql.SQLException

Sets the designated paramter to the given `String` object. The driver converts this to a SQL `NCHAR` or `NVARCHAR` or `LONGNVARCHAR` value (depending on the argument's size relative to the driver's limits on `NVARCHAR` values) when it sends it to the database.

Specified by:
  `setNString` in interface `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - of the first parameter is 1, the second is 2, ...
  `value` - the parameter value
Throws:
  `java.sql.SQLException` - if parameterIndex does not correspond to a parameter marker in the SQL statement; if the driver does not support national character sets; if the driver can detect that a data conversion error could occur; if a database access error occurs; or this method is called on a closed `PreparedStatement`
  `java.sql.SQLFeatureNotSupportedException` - if the JDBC driver does not support this method
Since:
  1.6

#### setNCharacterStream

    public void setNCharacterStream​(int parameterIndex,
                                    java.io.Reader value,
                                    long length)
                             throws java.sql.SQLException

Sets the designated parameter to a `Reader` object. The `Reader` reads the data till end-of-file is reached. The driver does the necessary conversion from Java character format to the national character set in the database.

Specified by:
  `setNCharacterStream` in interface `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - of the first parameter is 1, the second is 2, ...
  `value` - the parameter value
  `length` - the number of characters in the parameter data.
Throws:
  `java.sql.SQLException` - if parameterIndex does not correspond to a parameter marker in the SQL statement; if the driver does not support national character sets; if the driver can detect that a data conversion error could occur; if a database access error occurs; or this method is called on a closed `PreparedStatement`
  `java.sql.SQLFeatureNotSupportedException` - if the JDBC driver does not support this method
Since:
  1.6

#### setNClob

    public void setNClob​(int parameterIndex,
                         java.sql.NClob value)
                  throws java.sql.SQLException

Sets the designated parameter to a `java.sql.NClob` object. The driver converts this to a SQL `NCLOB` value when it sends it to the database.

Specified by:
  `setNClob` in interface `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - of the first parameter is 1, the second is 2, ...
  `value` - the parameter value
Throws:
  `java.sql.SQLException` - if parameterIndex does not correspond to a parameter marker in the SQL statement; if the driver does not support national character sets; if the driver can detect that a data conversion error could occur; if a database access error occurs; or this method is called on a closed `PreparedStatement`
  `java.sql.SQLFeatureNotSupportedException` - if the JDBC driver does not support this method
Since:
  1.6

#### setClob

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

Sets the designated parameter to a `Reader` object. The reader must contain the number of characters specified by length otherwise a `SQLException` will be generated when the `PreparedStatement` is executed. This method differs from the `setCharacterStream (int, Reader, int)` method because it informs the driver that the parameter value should be sent to the server as a `CLOB`. When the `setCharacterStream` method is used, the driver may have to do extra work to determine whether the parameter data should be sent to the server as a `LONGVARCHAR` or a `CLOB`

Specified by:
  `setClob` in interface `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - index of the first parameter is 1, the second is 2, ...
  `reader` - An object that contains the data to set the parameter value to.
  `length` - the number of characters in the parameter data.
Throws:
  `java.sql.SQLException` - if parameterIndex does not correspond to a parameter marker in the SQL statement; if a database access error occurs; this method is called on a closed `PreparedStatement` or if the length specified is less than zero.
  `java.sql.SQLFeatureNotSupportedException` - if the JDBC driver does not support this method
Since:
  1.6

#### setBlob

    public void setBlob​(int parameterIndex,
                        java.io.InputStream inputStream,
                        long length)
                 throws java.sql.SQLException

Sets the designated parameter to a `InputStream` object. The inputstream must contain the number of characters specified by length otherwise a `SQLException` will be generated when the `PreparedStatement` is executed. This method differs from the `setBinaryStream (int, InputStream, int)` method because it informs the driver that the parameter value should be sent to the server as a `BLOB`. When the `setBinaryStream` method is used, the driver may have to do extra work to determine whether the parameter data should be sent to the server as a `LONGVARBINARY` or a `BLOB`

Specified by:
  `setBlob` in interface `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - index of the first parameter is 1, the second is 2, ...
  `inputStream` - An object that contains the data to set the parameter value to.
  `length` - the number of bytes in the parameter data.
Throws:
  `java.sql.SQLException` - if parameterIndex does not correspond to a parameter marker in the SQL statement; if a database access error occurs; this method is called on a closed `PreparedStatement`; if the length specified is less than zero or if the number of bytes in the inputstream does not match the specfied length.
  `java.sql.SQLFeatureNotSupportedException` - if the JDBC driver does not support this method
Since:
  1.6

#### setNClob

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

Sets the designated parameter to a `Reader` object. The reader must contain the number of characters specified by length otherwise a `SQLException` will be generated when the `PreparedStatement` is executed. This method differs from the `setCharacterStream (int, Reader, int)` method because it informs the driver that the parameter value should be sent to the server as a `NCLOB`. When the `setCharacterStream` method is used, the driver may have to do extra work to determine whether the parameter data should be sent to the server as a `LONGNVARCHAR` or a `NCLOB`

Specified by:
  `setNClob` in interface `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - index of the first parameter is 1, the second is 2, ...
  `reader` - An object that contains the data to set the parameter value to.
  `length` - the number of characters in the parameter data.
Throws:
  `java.sql.SQLException` - if parameterIndex does not correspond to a parameter marker in the SQL statement; if the length specified is less than zero; if the driver does not support national character sets; if the driver can detect that a data conversion error could occur; if a database access error occurs or this method is called on a closed `PreparedStatement`
  `java.sql.SQLFeatureNotSupportedException` - if the JDBC driver does not support this method
Since:
  1.6

#### setSQLXML

    public void setSQLXML​(int parameterIndex,
                          java.sql.SQLXML xmlObject)
                   throws java.sql.SQLException

Sets the designated parameter to the given `java.sql.SQLXML` object. The driver converts this to an SQL `XML` value when it sends it to the database.

Specified by:
  `setSQLXML` in interface `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - index of the first parameter is 1, the second is 2, ...
  `xmlObject` - a `SQLXML` object that maps an SQL `XML` value
Throws:
  `java.sql.SQLException` - if parameterIndex does not correspond to a parameter marker in the SQL statement; if a database access error occurs; this method is called on a closed `PreparedStatement` or the `java.xml.transform.Result`, `Writer` or `OutputStream` has not been closed for the `SQLXML` object
  `java.sql.SQLFeatureNotSupportedException` - if the JDBC driver does not support this method
Since:
  1.6

#### setAsciiStream

    public void setAsciiStream​(int parameterIndex,
                               java.io.InputStream x,
                               long length)
                        throws java.sql.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 `java.sql.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:
  `java.sql.SQLException` - if parameterIndex does not correspond to a parameter marker in the SQL statement; if a database access error occurs or this method is called on a closed `PreparedStatement`
Since:
  1.6

#### setBinaryStream

    public void setBinaryStream​(int parameterIndex,
                                java.io.InputStream x,
                                long length)
                         throws java.sql.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 `java.sql.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:
  `java.sql.SQLException` - if parameterIndex does not correspond to a parameter marker in the SQL statement; if a database access error occurs or this method is called on a closed `PreparedStatement`
Since:
  1.6

#### setCharacterStream

    public void setCharacterStream​(int parameterIndex,
                                   java.io.Reader reader,
                                   long length)
                            throws java.sql.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 `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - the first parameter is 1, the second is 2, ...
  `reader` - the `java.io.Reader` object that contains the Unicode data
  `length` - the number of characters in the stream
Throws:
  `java.sql.SQLException` - if parameterIndex does not correspond to a parameter marker in the SQL statement; if a database access error occurs or this method is called on a closed `PreparedStatement`
Since:
  1.6

#### setAsciiStream

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

Sets the designated parameter to the given input stream. 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.

Note: Consult your JDBC driver documentation to determine if it might be more efficient to use a version of `setAsciiStream` which takes a length parameter.

Specified by:
  `setAsciiStream` in interface `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - the first parameter is 1, the second is 2, ...
  `x` - the Java input stream that contains the ASCII parameter value
Throws:
  `java.sql.SQLException` - if parameterIndex does not correspond to a parameter marker in the SQL statement; if a database access error occurs or this method is called on a closed `PreparedStatement`
  `java.sql.SQLFeatureNotSupportedException` - if the JDBC driver does not support this method
Since:
  1.6

#### setBinaryStream

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

Sets the designated parameter to the given input stream. 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.

Note: Consult your JDBC driver documentation to determine if it might be more efficient to use a version of `setBinaryStream` which takes a length parameter.

Specified by:
  `setBinaryStream` in interface `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - the first parameter is 1, the second is 2, ...
  `x` - the java input stream which contains the binary parameter value
Throws:
  `java.sql.SQLException` - if parameterIndex does not correspond to a parameter marker in the SQL statement; if a database access error occurs or this method is called on a closed `PreparedStatement`
  `java.sql.SQLFeatureNotSupportedException` - if the JDBC driver does not support this method
Since:
  1.6

#### setCharacterStream

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

Sets the designated parameter to the given `Reader` object. 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.

Note: Consult your JDBC driver documentation to determine if it might be more efficient to use a version of `setCharacterStream` which takes a length parameter.

Specified by:
  `setCharacterStream` in interface `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - the first parameter is 1, the second is 2, ...
  `reader` - the `java.io.Reader` object that contains the Unicode data
Throws:
  `java.sql.SQLException` - if parameterIndex does not correspond to a parameter marker in the SQL statement; if a database access error occurs or this method is called on a closed `PreparedStatement`
  `java.sql.SQLFeatureNotSupportedException` - if the JDBC driver does not support this method
Since:
  1.6

#### setNCharacterStream

    public void setNCharacterStream​(int parameterIndex,
                                    java.io.Reader value)
                             throws java.sql.SQLException

Sets the designated parameter to a `Reader` object. The `Reader` reads the data till end-of-file is reached. The driver does the necessary conversion from Java character format to the national character set in the database.

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

Note: Consult your JDBC driver documentation to determine if it might be more efficient to use a version of `setNCharacterStream` which takes a length parameter.

Specified by:
  `setNCharacterStream` in interface `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - of the first parameter is 1, the second is 2, ...
  `value` - the parameter value
Throws:
  `java.sql.SQLException` - if parameterIndex does not correspond to a parameter marker in the SQL statement; if the driver does not support national character sets; if the driver can detect that a data conversion error could occur; if a database access error occurs; or this method is called on a closed `PreparedStatement`
  `java.sql.SQLFeatureNotSupportedException` - if the JDBC driver does not support this method
Since:
  1.6

#### setClob

    public void setClob​(int parameterIndex,
                        java.io.Reader reader)
                 throws java.sql.SQLException

Sets the designated parameter to a `Reader` object. This method differs from the `setCharacterStream (int, Reader)` method because it informs the driver that the parameter value should be sent to the server as a `CLOB`. When the `setCharacterStream` method is used, the driver may have to do extra work to determine whether the parameter data should be sent to the server as a `LONGVARCHAR` or a `CLOB`

Note: Consult your JDBC driver documentation to determine if it might be more efficient to use a version of `setClob` which takes a length parameter.

Specified by:
  `setClob` in interface `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - index of the first parameter is 1, the second is 2, ...
  `reader` - An object that contains the data to set the parameter value to.
Throws:
  `java.sql.SQLException` - if parameterIndex does not correspond to a parameter marker in the SQL statement; if a database access error occurs; this method is called on a closed `PreparedStatement`or if parameterIndex does not correspond to a parameter marker in the SQL statement
  `java.sql.SQLFeatureNotSupportedException` - if the JDBC driver does not support this method
Since:
  1.6

#### setBlob

    public void setBlob​(int parameterIndex,
                        java.io.InputStream inputStream)
                 throws java.sql.SQLException

Sets the designated parameter to a `InputStream` object. This method differs from the `setBinaryStream (int, InputStream)` method because it informs the driver that the parameter value should be sent to the server as a `BLOB`. When the `setBinaryStream` method is used, the driver may have to do extra work to determine whether the parameter data should be sent to the server as a `LONGVARBINARY` or a `BLOB`

Note: Consult your JDBC driver documentation to determine if it might be more efficient to use a version of `setBlob` which takes a length parameter.

Specified by:
  `setBlob` in interface `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - index of the first parameter is 1, the second is 2, ...
  `inputStream` - An object that contains the data to set the parameter value to.
Throws:
  `java.sql.SQLException` - if parameterIndex does not correspond to a parameter marker in the SQL statement; if a database access error occurs; this method is called on a closed `PreparedStatement` or if parameterIndex does not correspond to a parameter marker in the SQL statement,
  `java.sql.SQLFeatureNotSupportedException` - if the JDBC driver does not support this method
Since:
  1.6

#### setNClob

    public void setNClob​(int parameterIndex,
                         java.io.Reader reader)
                  throws java.sql.SQLException

Sets the designated parameter to a `Reader` object. This method differs from the `setCharacterStream (int, Reader)` method because it informs the driver that the parameter value should be sent to the server as a `NCLOB`. When the `setCharacterStream` method is used, the driver may have to do extra work to determine whether the parameter data should be sent to the server as a `LONGNVARCHAR` or a `NCLOB`

Note: Consult your JDBC driver documentation to determine if it might be more efficient to use a version of `setNClob` which takes a length parameter.

Specified by:
  `setNClob` in interface `java.sql.PreparedStatement`
Parameters:
  `parameterIndex` - index of the first parameter is 1, the second is 2, ...
  `reader` - An object that contains the data to set the parameter value to.
Throws:
  `java.sql.SQLException` - if parameterIndex does not correspond to a parameter marker in the SQL statement; if the driver does not support national character sets; if the driver can detect that a data conversion error could occur; if a database access error occurs or this method is called on a closed `PreparedStatement`
  `java.sql.SQLFeatureNotSupportedException` - if the JDBC driver does not support this method
Since:
  1.6

#### setClosed

    protected void setClosed​(boolean flag)