/*
* Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package javax.sql.rowset;
import java.sql.*;
import javax.sql.*;
import java.util.*;
import java.io.*;
import java.math.*;
import java.io.Serializable;
import javax.sql.rowset.serial.*;
/**
* An abstract class providing a RowSet
object with its basic functionality.
* The basic functions include having properties and sending event notifications,
* which all JavaBeansTM components must implement.
*
*
BaseRowSet
class provides the core functionality
* for all RowSet
implementations,
* and all standard implementations may use this class in combination with
* one or more RowSet
interfaces in order to provide a standard
* vendor-specific implementation. To clarify, all implementations must implement
* at least one of the RowSet
interfaces (JdbcRowSet
,
* CachedRowSet
, JoinRowSet
, FilteredRowSet
,
* or WebRowSet
). This means that any implementation that extends
* the BaseRowSet
class must also implement one of the RowSet
* interfaces.
*
* The BaseRowSet
class provides the following:
*
*
*
*
RowSet
object's command
* *
*
RowSet
implementation does and how it gets
* its data. For example,
* rowsets that get their data from a ResultSet
object need to
* set the properties that are required for making a database connection.
* If a RowSet
object uses the DriverManager
facility to make a
* connection, it needs to set a property for the JDBC URL that identifies the
* appropriate driver, and it needs to set the properties that give the
* user name and password.
* If, on the other hand, the rowset uses a DataSource
object
* to make the connection, which is the preferred method, it does not need to
* set the property for the JDBC URL. Instead, it needs to set the property
* for the logical name of the data source along with the properties for
* the user name and password.
*
* NOTE: In order to use a DataSource
object for making a
* connection, the DataSource
object must have been registered
* with a naming service that uses the Java Naming and Directory
* InterfaceTM (JNDI) API. This registration
* is usually done by a person acting in the capacity of a system administrator.
*
*
ResultSet
object. This query is the command that is set
* for the RowSet
object's command property. The rowset populates itself with data by reading the
* data from the ResultSet
object into itself. If the query
* contains placeholders for values to be set, the BaseRowSet
setter methods
* are used to set these values. All setter methods allow these values to be set
* to null
if required.
*
* The following code fragment illustrates how the
* CachedRowSet
TM
* object crs
might have its command property set. Note that if a
* tool is used to set properties, this is the code that the tool would use.
*
* crs.setCommand("SELECT FIRST_NAME, LAST_NAME, ADDRESS FROM CUSTOMERS" + * "WHERE CREDIT_LIMIT > ? AND REGION = ?"); **
* In this example, the values for CREDIT_LIMIT
and
* REGION
are placeholder parameters, which are indicated with a
* question mark (?). The first question mark is placeholder parameter number
* 1
, the second question mark is placeholder parameter number
* 2
, and so on. Any placeholder parameters must be set with
* values before the query can be executed. To set these
* placeholder parameters, the BaseRowSet
class provides a set of setter
* methods, similar to those provided by the PreparedStatement
* interface, for setting values of each data type. A RowSet
object stores the
* parameter values internally, and its execute
method uses them internally
* to set values for the placeholder parameters
* before it sends the command to the DBMS to be executed.
*
* The following code fragment demonstrates * setting the two parameters in the query from the previous example. *
* crs.setInt(1, 5000); * crs.setString(2, "West"); ** If the
execute
method is called at this point, the query
* sent to the DBMS will be:
* * "SELECT FIRST_NAME, LAST_NAME, ADDRESS FROM CUSTOMERS" + * "WHERE CREDIT_LIMIT > 5000 AND REGION = 'West'" ** NOTE: Setting
Array
, Clob
, Blob
and
* Ref
objects as a command parameter, stores these values as
* SerialArray
, SerialClob
, SerialBlob
* and SerialRef
objects respectively.
*
* BaseRowSet
class provides two kinds of setter methods,
* those that set properties and those that set placeholder parameters. The setter
* methods discussed in this section are those that set placeholder parameters.
*
* The placeholder parameters set with the BaseRowSet
setter methods
* are stored as objects in an internal Hashtable
object.
* Primitives are stored as their Object
type. For example, byte
* is stored as Byte
object, and int
is stored as
* an Integer
object.
* When the method execute
is called, the values in the
* Hashtable
object are substituted for the appropriate placeholder
* parameters in the command.
*
* A call to the method getParams
returns the values stored in the
* Hashtable
object as an array of Object
instances.
* An element in this array may be a simple Object
instance or an
* array (which is a type of Object
). The particular setter method used
* determines whether an element in this array is an Object
or an array.
*
* The majority of methods for setting placeholder parameters take two parameters,
* with the first parameter
* indicating which placeholder parameter is to be set, and the second parameter
* giving the value to be set. Methods such as setInt
,
* setString
, setBoolean
, and setLong
fall into
* this category. After these methods have been called, a call to the method
* getParams
will return an array with the values that have been set. Each
* element in the array is an Object
instance representing the
* values that have been set. The order of these values in the array is determined by the
* int
(the first parameter) passed to the setter method. The values in the
* array are the values (the second parameter) passed to the setter method.
* In other words, the first element in the array is the value
* to be set for the first placeholder parameter in the RowSet
object's
* command. The second element is the value to
* be set for the second placeholder parameter, and so on.
*
* Several setter methods send the driver and DBMS information beyond the value to be set.
* When the method getParams
is called after one of these setter methods has
* been used, the elements in the array will themselves be arrays to accommodate the
* additional information. In this category, the method setNull
is a special case
* because one version takes only
* two parameters (setNull(int parameterIndex, int SqlType)
). Nevertheless,
* it requires
* an array to contain the information that will be passed to the driver and DBMS. The first
* element in this array is the value to be set, which is null
, and the
* second element is the int
supplied for sqlType, which
* indicates the type of SQL value that is being set to null
. This information
* is needed by some DBMSs and is therefore required in order to ensure that applications
* are portable.
* The other version is intended to be used when the value to be set to null
* is a user-defined type. It takes three parameters
* (setNull(int parameterIndex, int sqlType, String typeName)
) and also
* requires an array to contain the information to be passed to the driver and DBMS.
* The first two elements in this array are the same as for the first version of
* setNull
. The third element, typeName, gives the SQL name of
* the user-defined type. As is true with the other setter methods, the number of the
* placeholder parameter to be set is indicated by an element's position in the array
* returned by getParams
. So, for example, if the parameter
* supplied to setNull
is 2
, the second element in the array
* returned by getParams
will be an array of two or three elements.
*
* Some methods, such as setObject
and setDate
have versions
* that take more than two parameters, with the extra parameters giving information
* to the driver or the DBMS. For example, the methods setDate
,
* setTime
, and setTimestamp
can take a Calendar
* object as their third parameter. If the DBMS does not store time zone information,
* the drivern uses the Calendar
object to construct the Date
,
* Time
, or Timestamp
object being set. As is true with other
* methods that provide additional information, the element in the array returned
* by getParams
is an array instead of a simple Object
instance.
*
* The methods setAsciiStream
, setBinaryStream
,
* setCharacterStream
, and setUnicodeStream
(which is
* deprecated, so applications should use getCharacterStream
instead)
* take three parameters, so for them, the element in the array returned by
* getParams
is also an array. What is different about these setter
* methods is that in addition to the information provided by parameters, the array contains
* one of the BaseRowSet
constants indicating the type of stream being set.
*
* NOTE: The method getParams
is called internally by
* RowSet
implementations extending this class; it is not normally called by an
* application programmer directly.
*
*
BaseRowSet
class provides the event notification
* mechanism for rowsets. It contains the field
* listeners
, methods for adding and removing listeners, and
* methods for notifying listeners of changes.
*
* A listener is an object that has implemented the RowSetListener
interface.
* If it has been added to a RowSet
object's list of listeners, it will be notified
* when an event occurs on that RowSet
object. Each listener's
* implementation of the RowSetListener
methods defines what that object
* will do when it is notified that an event has occurred.
*
* There are three possible events for a RowSet
object:
*
RowSet
object are changed
*
* The BaseRowSet
method used for the notification indicates the
* type of event that has occurred. For example, the method
* notifyRowChanged
indicates that a row has been updated,
* deleted, or inserted. Each of the notification methods creates a
* RowSetEvent
object, which is supplied to the listener in order to
* identify the RowSet
object on which the event occurred.
* What the listener does with this information, which may be nothing, depends on how it was
* implemented.
*
*
BaseRowSet
object is initialized with many starting values.
*
* The following is true of a default RowSet
instance that extends
* the BaseRowSet
class:
* RowSet
object's command.
* BINARY
, VARBINARY
,
* LONGVARBINARY
, CHAR
, VARCHAR
,
* and LONGVARCHAR
.
* null
.
* Vector
object for storing the values set
* for the placeholder parameters in the RowSet
object's command.
*
* If other values are desired, an application must set the property values
* explicitly. For example, the following line of code sets the maximum number
* of rows for the CachedRowSet
object crs to 500.
*
* crs.setMaxRows(500); ** Methods implemented in extensions of this
BaseRowSet
class must throw an
* SQLException
object for any violation of the defined assertions. Also, if the
* extending class overrides and reimplements any BaseRowSet
method and encounters
* connectivity or underlying data source issues, that method may in addition throw an
* SQLException
object for that reason.
*/
public abstract class BaseRowSet implements Serializable, Cloneable {
/**
* A constant indicating to a RowSetReaderImpl
object
* that a given parameter is a Unicode stream. This
* RowSetReaderImpl
object is provided as an extension of the
* SyncProvider
abstract class defined in the
* SyncFactory
static factory SPI mechanism.
*/
public static final int UNICODE_STREAM_PARAM = 0;
/**
* A constant indicating to a RowSetReaderImpl
object
* that a given parameter is a binary stream. A
* RowSetReaderImpl
object is provided as an extension of the
* SyncProvider
abstract class defined in the
* SyncFactory
static factory SPI mechanism.
*/
public static final int BINARY_STREAM_PARAM = 1;
/**
* A constant indicating to a RowSetReaderImpl
object
* that a given parameter is an ASCII stream. A
* RowSetReaderImpl
object is provided as an extension of the
* SyncProvider
abstract class defined in the
* SyncFactory
static factory SPI mechanism.
*/
public static final int ASCII_STREAM_PARAM = 2;
/**
* The InputStream
object that will be
* returned by the method getBinaryStream
, which is
* specified in the ResultSet
interface.
* @serial
*/
protected java.io.InputStream binaryStream;
/**
* The InputStream
object that will be
* returned by the method getUnicodeStream
,
* which is specified in the ResultSet
interface.
* @serial
*/
protected java.io.InputStream unicodeStream;
/**
* The InputStream
object that will be
* returned by the method getAsciiStream
,
* which is specified in the ResultSet
interface.
* @serial
*/
protected java.io.InputStream asciiStream;
/**
* The Reader
object that will be
* returned by the method getCharacterStream
,
* which is specified in the ResultSet
interface.
* @serial
*/
protected java.io.Reader charStream;
/**
* The query that will be sent to the DBMS for execution when the
* method execute
is called.
* @serial
*/
private String command;
/**
* The JDBC URL the reader, writer, or both supply to the method
* DriverManager.getConnection
when the
* DriverManager
is used to get a connection.
*
* The JDBC URL identifies the driver to be used to make the conndection.
* This URL can be found in the documentation supplied by the driver
* vendor.
* @serial
*/
private String URL;
/**
* The logical name of the data source that the reader/writer should use
* in order to retrieve a DataSource
object from a Java
* Directory and Naming Interface (JNDI) naming service.
* @serial
*/
private String dataSource;
/**
* The user name the reader, writer, or both supply to the method
* DriverManager.getConnection
when the
* DriverManager
is used to get a connection.
* @serial
*/
private transient String username;
/**
* The password the reader, writer, or both supply to the method
* DriverManager.getConnection
when the
* DriverManager
is used to get a connection.
* @serial
*/
private transient String password;
/**
* A constant indicating the type of this JDBC RowSet
* object. It must be one of the following ResultSet
* constants: TYPE_FORWARD_ONLY
,
* TYPE_SCROLL_INSENSITIVE
, or
* TYPE_SCROLL_SENSITIVE
.
* @serial
*/
private int rowSetType = ResultSet.TYPE_SCROLL_INSENSITIVE;
/**
* A boolean
indicating whether deleted rows are visible in this
* JDBC RowSet
object .
* @serial
*/
private boolean showDeleted = false; // default is false
/**
* The maximum number of seconds the driver
* will wait for a command to execute. This limit applies while
* this JDBC RowSet
object is connected to its data
* source, that is, while it is populating itself with
* data and while it is writing data back to the data source.
* @serial
*/
private int queryTimeout = 0; // default is no timeout
/**
* The maximum number of rows the reader should read.
* @serial
*/
private int maxRows = 0; // default is no limit
/**
* The maximum field size the reader should read.
* @serial
*/
private int maxFieldSize = 0; // default is no limit
/**
* A constant indicating the concurrency of this JDBC RowSet
* object. It must be one of the following ResultSet
* constants: CONCUR_READ_ONLY
or
* CONCUR_UPDATABLE
.
* @serial
*/
private int concurrency = ResultSet.CONCUR_UPDATABLE;
/**
* A boolean
indicating whether this JDBC RowSet
* object is read-only. true
indicates that it is read-only;
* false
that it is writable.
* @serial
*/
private boolean readOnly;
/**
* A boolean
indicating whether the reader for this
* JDBC RowSet
object should perform escape processing.
* true
means that escape processing is turned on;
* false
that it is not. The default is true
.
* @serial
*/
private boolean escapeProcessing;
/**
* A constant indicating the isolation level of the connection
* for this JDBC RowSet
object . It must be one of
* the following Connection
constants:
* TRANSACTION_NONE
,
* TRANSACTION_READ_UNCOMMITTED
,
* TRANSACTION_READ_COMMITTED
,
* TRANSACTION_REPEATABLE_READ
or
* TRANSACTION_SERIALIZABLE
.
* @serial
*/
private int isolation;
/**
* A constant used as a hint to the driver that indicates the direction in
* which data from this JDBC RowSet
object is going
* to be fetched. The following ResultSet
constants are
* possible values:
* FETCH_FORWARD
,
* FETCH_REVERSE
,
* FETCH_UNKNOWN
.
*
* Unused at this time.
* @serial
*/
private int fetchDir = ResultSet.FETCH_FORWARD; // default fetch direction
/**
* A hint to the driver that indicates the expected number of rows
* in this JDBC RowSet
object .
*
* Unused at this time.
* @serial
*/
private int fetchSize = 0; // default fetchSize
/**
* The
* A listener might, for example, be a table or graph that needs to
* be updated in order to accurately reflect the current state of
* the
* Note: if the
* Note: if the listener is already set, and the new
* When an application calls a method to move the cursor,
* that method moves the cursor and then calls this method
* internally. An application should never invoke
* this method directly.
*
* @throws SQLException if the class extending the
* When an application calls a method that changes a row, such as
* the
* When an application calls methods that change the entire contents
* of the
* The SQL query returned by this method is used by
* The command is used by the
* The default value for the
* The
* The
* Setting the Url property is optional if connections are established using
* a
* Users should set either the url or the data source name property.
* The driver will use the property set most recently to establish a
* connection.
*
* @return a
* Users should set either the Url property or the dataSourceName property.
* If both properties are set, the driver will use the property set most recently.
*
* @param name a
* @param concurrency one of the following constants:
*
* For
* For
* Drivers that support the JDBC 3.0 API will create
*
* If a type map is explicitly supplied to a method that can perform
* custom mapping, that type map supersedes the connection's type map.
*
* @return the
* Note: Since
* Note: Allowing deleted rows to remain visible complicates the behavior
* of some of the methods. However, most
* A
* This method applies to a
* A
* A
* This method applies to a
* A
* For
*
* @param rows the number of rows to fetch;
* An application can call the method
* @return the concurrency type for this
* This method is called by many methods internally; it is never
* called by an application directly.
*
* @param idx an
* Note that the second parameter tells the DBMS the data type of the value being
* set to
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* NOTE:
* Calls made to the method
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* parameterIndex is parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this Note: To be portable, applications must give the
* SQL type code and the fully qualified SQL type name when specifying
* a
* If the parameter does not have a user-defined or
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* NOTE:
* Calls made to the method
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* parameterIndex is parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* NOTE:
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* NOTE:
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* NOTE:
* @param parameterIndex the ordinal number of the placeholder parameter
* in this
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* NOTE:
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* NOTE:
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* NOTE:
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* NOTE:
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* Note:
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* NOTE:
* @param parameterIndex the ordinal number of the placeholder parameter
* in this
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* NOTE:
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* NOTE:
* Calls made to the method
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* NOTE:
* Calls made to the method
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* parameterIndex is parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* NOTE:
* Calls made to the method
* When a very large ASCII value is input to a Note: This stream object can be either a standard
* Java stream object or your own subclass that implements the
* standard interface.
*
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* Note:
* Calls made to the method
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* parameterIndex is element number parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this 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
*
* When a very large binary value is input to a
* Note: This stream object can be either a standard
* Java stream object or your own subclass that implements the
* standard interface.
*
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* NOTE:
* Calls made to the method
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* parameterIndex is element number parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this 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
*
* When a very large Unicode value is input to a
* Note: This stream object can be either a standard
* Java stream object or your own subclass that implements the
* standard interface.
*
* This method is deprecated; the method
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* parameterIndex is element number parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this
* When a very large Unicode value is input to a
* Note: This stream object can be either a standard
* Java stream object or your own subclass that implements the
* standard interface.
*
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* NOTE:
* Calls made to the method
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* parameterIndex is element number parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this 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
*
* The driver converts this object to the specified
* target SQL type before sending it to the database.
* If the object has a custom mapping (is of a class implementing
*
* Note that this method may be used to pass database-
* specific abstract data types.
*
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* NOTE:
* Calls made to the method
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* parameterIndex is element number parameterIndex -1.
*
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* NOTE:
* Calls made to the method
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* parameterIndex is element number parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this
* The JDBC specification defines a standard mapping from
* Java
* If, on the other hand, the object is of a class
* implementing
* This method throws an exception if there
* is an ambiguity, for example, if the object is of a class
* implementing more than one interface.
*
* Note that this method may be used to pass database-specific
* abstract data types.
*
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* NOTE:
* After this method has been called, a call to the
* method
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* NOTE:
* After this method has been called, a call to the
* method
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* After this method has been called, a call to the
* method
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* NOTE:
* After this method has been called, a call to the
* method
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* Note:
* After this method has been called, a call to the
* method
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* NOTE:
* Calls made to the method
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* parameterIndex is parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this
* When the DBMS does not store time zone information, the driver will use
* the given
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* NOTE:
* Calls made to the method
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* parameterIndex is parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this
* When the DBMS does not store time zone information, the driver will use
* the given
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this
* NOTE:
* Calls made to the method
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* parameterIndex is parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this
* In general, parameter values remain in force for repeated use in
* this
* This method is called internally by the
* Furthermore, this method differs from the
* Each element in the array that is returned is an
* NOTE: Stored parameter values of types Note: You must specify the parameter's SQL type.
*
* @param parameterName the name of the parameter
* @param sqlType the SQL type code defined in 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.
*
*
* @param parameterName the name of the parameter
* @param sqlType a value from Note: This stream object can either be a standard
* Java stream object or your own subclass that implements the
* standard interface.
*
* @param parameterName the name of the parameter
* @param x the Java input stream that contains the ASCII parameter value
* @param length the number of bytes in the stream
* @exception SQLException if a database access error occurs or
* this method is called on a closed Note: This stream object can either be a standard
* Java stream object or your own subclass that implements the
* standard interface.
*
* @param parameterName the name of the parameter
* @param x the java input stream which contains the binary parameter value
* @param length the number of bytes in the stream
* @exception SQLException if a database access error occurs or
* this method is called on a closed Note: This stream object can either be a standard
* Java stream object or your own subclass that implements the
* standard interface.
*
* @param parameterName the name of the parameter
* @param reader the 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
* 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
* 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
* 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
* 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
* Note that this method may be used to pass datatabase-
* specific abstract data types.
*
* @param parameterName the name of the parameter
* @param x the object containing the input parameter value
* @param targetSqlType the SQL type (as defined in java.sql.Types) to be
* sent to the database. The scale argument may further qualify this type.
* @param 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.
* @exception SQLException if a database access error occurs or
* this method is called on a closed The JDBC specification specifies a standard mapping from
* Java 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
* 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.
*
* @param parameterName the name of the parameter
* @param x the object containing the input parameter value
* @exception SQLException if a database access error occurs,
* this method is called on a closed Note: Consult your JDBC driver documentation to determine if
* it might be more efficient to use a version of
* Note: Consult your JDBC driver documentation to determine if
* it might be more efficient to use a version of
* Note: Consult your JDBC driver documentation to determine if
* it might be more efficient to use a version of
* Note: Consult your JDBC driver documentation to determine if
* it might be more efficient to use a version of
* 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
* Note: Consult your JDBC driver documentation to determine if
* it might be more efficient to use a version of
* Note: Consult your JDBC driver documentation to determine if
* it might be more efficient to use a version of
* java.util.Map
object that contains entries mapping
* SQL type names to classes in the Java programming language for the
* custom mapping of user-defined types.
* @serial
*/
private MapVector
object that holds the list of listeners
* that have registered with this RowSet
object.
* @serial
*/
private VectorVector
object that holds the parameters set
* for this RowSet
object's current command.
* @serial
*/
private HashtableBaseRowSet
object initialized with
* a default Vector
object for its listeners
* field. The other default values with which it is initialized are listed
* in Section 6.0 of the class comment for this class.
*/
public BaseRowSet() {
// allocate the listeners collection
listeners = new VectorRowSet
implementation to start using
* the standard facilities provided by a BaseRowSet
* instance. This method should be called after the RowSet
object
* has been instantiated to correctly initialize all parameters. This method
* should never be called by an application, but is called from with
* a RowSet
implementation extending this class.
*/
protected void initParams() {
params = new HashtableRowSet
* object.
* RowSet
object.
* RowSetListener
object is
* null
, this method silently discards the null
* value and does not add a null reference to the set of listeners.
* RowSetListerner
* instance is added to the set of listeners already registered to receive
* event notifications from this RowSet
.
*
* @param listener an object that has implemented the
* javax.sql.RowSetListener
interface and wants to be notified
* of any events that occur on this RowSet
object; May be
* null.
* @see #removeRowSetListener
*/
public void addRowSetListener(RowSetListener listener) {
listeners.add(listener);
}
/**
* Removes the designated object from this RowSet
object's list of listeners.
* If the given argument is not a registered listener, this method
* does nothing.
*
* Note: if the RowSetListener
object is
* null
, this method silently discards the null
* value.
*
* @param listener a RowSetListener
object that is on the list
* of listeners for this RowSet
object
* @see #addRowSetListener
*/
public void removeRowSetListener(RowSetListener listener) {
listeners.remove(listener);
}
/**
* Determine if instance of this class extends the RowSet interface.
*/
private void checkforRowSetInterface() throws SQLException {
if ((this instanceof javax.sql.RowSet) == false) {
throw new SQLException("The class extending abstract class BaseRowSet " +
"must implement javax.sql.RowSet or one of it's sub-interfaces.");
}
}
/**
* Notifies all of the listeners registered with this
* RowSet
object that its cursor has moved.
* BaseRowSet
* abstract class does not implement the RowSet
interface or
* one of it's sub-interfaces.
*/
protected void notifyCursorMoved() throws SQLException {
checkforRowSetInterface();
if (listeners.isEmpty() == false) {
RowSetEvent event = new RowSetEvent((RowSet)this);
for (RowSetListener rsl : listeners) {
rsl.cursorMoved(event);
}
}
}
/**
* Notifies all of the listeners registered with this RowSet
object that
* one of its rows has changed.
* CachedRowSet
methods insertRow
,
* updateRow
, or deleteRow
,
* that method calls notifyRowChanged
* internally. An application should never invoke
* this method directly.
*
* @throws SQLException if the class extending the BaseRowSet
* abstract class does not implement the RowSet
interface or
* one of it's sub-interfaces.
*/
protected void notifyRowChanged() throws SQLException {
checkforRowSetInterface();
if (listeners.isEmpty() == false) {
RowSetEvent event = new RowSetEvent((RowSet)this);
for (RowSetListener rsl : listeners) {
rsl.rowChanged(event);
}
}
}
/**
* Notifies all of the listeners registered with this RowSet
* object that its entire contents have changed.
* RowSet
object, such as the CachedRowSet
methods
* execute
, populate
, restoreOriginal
,
* or release
, that method calls notifyRowSetChanged
* internally (either directly or indirectly). An application should
* never invoke this method directly.
*
* @throws SQLException if the class extending the BaseRowSet
* abstract class does not implement the RowSet
interface or
* one of it's sub-interfaces.
*/
protected void notifyRowSetChanged() throws SQLException {
checkforRowSetInterface();
if (listeners.isEmpty() == false) {
RowSetEvent event = new RowSetEvent((RowSet)this);
for (RowSetListener rsl : listeners) {
rsl.rowSetChanged(event);
}
}
}
/**
* Retrieves the SQL query that is the command for this
* RowSet
object. The command property contains the query that
* will be executed to populate this RowSet
object.
* RowSet
methods
* such as execute
and populate
, which may be implemented
* by any class that extends the BaseRowSet
abstract class and
* implements one or more of the standard JSR-114 RowSet
* interfaces.
* RowSet
object's
* reader to obtain a ResultSet
object. The reader then
* reads the data from the ResultSet
object and uses it to
* to populate this RowSet
object.
* command
property is null
.
*
* @return the String
that is the value for this
* RowSet
object's command
property;
* may be null
* @see #setCommand
*/
public String getCommand() {
return command;
}
/**
* Sets this RowSet
object's command
property to
* the given String
object and clears the parameters, if any,
* that were set for the previous command.
* command
property may not be needed if the RowSet
* object gets its data from a source that does not support commands,
* such as a spreadsheet or other tabular file.
* Thus, this property is optional and may be null
.
*
* @param cmd a String
object containing an SQL query
* that will be set as this RowSet
object's command
* property; may be null
but may not be an empty string
* @throws SQLException if an empty string is provided as the command value
* @see #getCommand
*/
public void setCommand(String cmd) throws SQLException {
// cmd equal to null or
// cmd with length 0 (implies url =="")
// are not independent events.
if(cmd == null) {
command = null;
} else if (cmd.length() == 0) {
throw new SQLException("Invalid command string detected. " +
"Cannot be of length less than 0");
} else {
// "unbind" any parameters from any previous command.
if(params == null){
throw new SQLException("Set initParams() before setCommand");
}
params.clear();
command = cmd;
}
}
/**
* Retrieves the JDBC URL that this RowSet
object's
* javax.sql.Reader
object uses to make a connection
* with a relational database using a JDBC technology-enabled driver.
*Url
property will be null
if the underlying data
* source is a non-SQL data source, such as a spreadsheet or an XML
* data source.
*
* @return a String
object that contains the JDBC URL
* used to establish the connection for this RowSet
* object; may be null
(default value) if not set
* @throws SQLException if an error occurs retrieving the URL value
* @see #setUrl
*/
public String getUrl() throws SQLException {
return URL;
}
/**
* Sets the Url property for this RowSet
object
* to the given String
object and sets the dataSource name
* property to null
. The Url property is a
* JDBC URL that is used when
* the connection is created using a JDBC technology-enabled driver
* ("JDBC driver") and the DriverManager
.
* The correct JDBC URL for the specific driver to be used can be found
* in the driver documentation. Although there are guidelines for for how
* a JDBC URL is formed,
* a driver vendor can specify any String
object except
* one with a length of 0
(an empty string).
* DataSource
object instead of the DriverManager
.
* The driver will use either the URL property or the
* dataSourceName property to create a connection, whichever was
* specified most recently. If an application uses a JDBC URL, it
* must load a JDBC driver that accepts the JDBC URL before it uses the
* RowSet
object to connect to a database. The RowSet
* object will use the URL internally to create a database connection in order
* to read or write data.
*
* @param url a String
object that contains the JDBC URL
* that will be used to establish the connection to a database for this
* RowSet
object; may be null
but must not
* be an empty string
* @throws SQLException if an error occurs setting the Url property or the
* parameter supplied is a string with a length of 0
(an
* empty string)
* @see #getUrl
*/
public void setUrl(String url) throws SQLException {
if(url == null) {
url = null;
} else if (url.length() < 1) {
throw new SQLException("Invalid url string detected. " +
"Cannot be of length less than 1");
} else {
URL = url;
}
dataSource = null;
}
/**
* Returns the logical name that when supplied to a naming service
* that uses the Java Naming and Directory Interface (JNDI) API, will
* retrieve a javax.sql.DataSource
object. This
* DataSource
object can be used to establish a connection
* to the data source that it represents.
* String
object that identifies the
* DataSource
object to be used for making a
* connection; if no logical name has been set, null
* is returned.
* @see #setDataSourceName
*/
public String getDataSourceName() {
return dataSource;
}
/**
* Sets the DataSource
name property for this RowSet
* object to the given logical name and sets this RowSet
object's
* Url property to null
. The name must have been bound to a
* DataSource
object in a JNDI naming service so that an
* application can do a lookup using that name to retrieve the
* DataSource
object bound to it. The DataSource
* object can then be used to establish a connection to the data source it
* represents.
* String
object with the name that can be supplied
* to a naming service based on JNDI technology to retrieve the
* DataSource
object that can be used to get a connection;
* may be null
but must not be an empty string
* @throws SQLException if an empty string is provided as the DataSource
* name
* @see #getDataSourceName
*/
public void setDataSourceName(String name) throws SQLException {
if (name == null) {
dataSource = null;
} else if (name.equals("")) {
throw new SQLException("DataSource name cannot be empty string");
} else {
dataSource = name;
}
URL = null;
}
/**
* Returns the user name used to create a database connection. Because it
* is not serialized, the username property is set at runtime before
* calling the method execute
.
*
* @return the String
object containing the user name that
* is supplied to the data source to create a connection; may be
* null
(default value) if not set
* @see #setUsername
*/
public String getUsername() {
return username;
}
/**
* Sets the username property for this RowSet
object
* to the given user name. Because it
* is not serialized, the username property is set at run time before
* calling the method execute
.
*
* @param name the String
object containing the user name that
* is supplied to the data source to create a connection. It may be null.
* @see #getUsername
*/
public void setUsername(String name) {
if(name == null)
{
username = null;
} else {
username = name;
}
}
/**
* Returns the password used to create a database connection for this
* RowSet
object. Because the password property is not
* serialized, it is set at run time before calling the method
* execute
. The default value is null
*
* @return the String
object that represents the password
* that must be supplied to the database to create a connection
* @see #setPassword
*/
public String getPassword() {
return password;
}
/**
* Sets the password used to create a database connection for this
* RowSet
object to the given String
* object. Because the password property is not
* serialized, it is set at run time before calling the method
* execute
.
*
* @param pass the String
object that represents the password
* that is supplied to the database to create a connection. It may be
* null.
* @see #getPassword
*/
public void setPassword(String pass) {
if(pass == null)
{
password = null;
} else {
password = pass;
}
}
/**
* Sets the type for this RowSet
object to the specified type.
* The default type is ResultSet.TYPE_SCROLL_INSENSITIVE
.
*
* @param type one of the following constants:
* ResultSet.TYPE_FORWARD_ONLY
,
* ResultSet.TYPE_SCROLL_INSENSITIVE
, or
* ResultSet.TYPE_SCROLL_SENSITIVE
* @throws SQLException if the parameter supplied is not one of the
* following constants:
* ResultSet.TYPE_FORWARD_ONLY
or
* ResultSet.TYPE_SCROLL_INSENSITIVE
* ResultSet.TYPE_SCROLL_SENSITIVE
* @see #getConcurrency
* @see #getType
*/
public void setType(int type) throws SQLException {
if ((type != ResultSet.TYPE_FORWARD_ONLY) &&
(type != ResultSet.TYPE_SCROLL_INSENSITIVE) &&
(type != ResultSet.TYPE_SCROLL_SENSITIVE)) {
throw new SQLException("Invalid type of RowSet set. Must be either " +
"ResultSet.TYPE_FORWARD_ONLY or ResultSet.TYPE_SCROLL_INSENSITIVE " +
"or ResultSet.TYPE_SCROLL_SENSITIVE.");
}
this.rowSetType = type;
}
/**
* Returns the type of this RowSet
object. The type is initially
* determined by the statement that created the RowSet
object.
* The RowSet
object can call the method
* setType
at any time to change its
* type. The default is TYPE_SCROLL_INSENSITIVE
.
*
* @return the type of this JDBC RowSet
* object, which must be one of the following:
* ResultSet.TYPE_FORWARD_ONLY
,
* ResultSet.TYPE_SCROLL_INSENSITIVE
, or
* ResultSet.TYPE_SCROLL_SENSITIVE
* @throws SQLException if an error occurs getting the type of
* of this RowSet
object
* @see #setType
*/
public int getType() throws SQLException {
return rowSetType;
}
/**
* Sets the concurrency for this RowSet
object to
* the specified concurrency. The default concurrency for any RowSet
* object (connected or disconnected) is ResultSet.CONCUR_UPDATABLE
,
* but this method may be called at any time to change the concurrency.
* ResultSet.CONCUR_READ_ONLY
or
* ResultSet.CONCUR_UPDATABLE
* @throws SQLException if the parameter supplied is not one of the
* following constants:
* ResultSet.CONCUR_UPDATABLE
or
* ResultSet.CONCUR_READ_ONLY
* @see #getConcurrency
* @see #isReadOnly
*/
public void setConcurrency(int concurrency) throws SQLException {
if((concurrency != ResultSet.CONCUR_READ_ONLY) &&
(concurrency != ResultSet.CONCUR_UPDATABLE)) {
throw new SQLException("Invalid concurrency set. Must be either " +
"ResultSet.CONCUR_READ_ONLY or ResultSet.CONCUR_UPDATABLE.");
}
this.concurrency = concurrency;
}
/**
* Returns a boolean
indicating whether this
* RowSet
object is read-only.
* Any attempts to update a read-only RowSet
object will result in an
* SQLException
being thrown. By default,
* rowsets are updatable if updates are possible.
*
* @return true
if this RowSet
object
* cannot be updated; false
otherwise
* @see #setConcurrency
* @see #setReadOnly
*/
public boolean isReadOnly() {
return readOnly;
};
/**
* Sets this RowSet
object's readOnly property to the given boolean
.
*
* @param value true
to indicate that this
* RowSet
object is read-only;
* false
to indicate that it is updatable
*/
public void setReadOnly(boolean value) {
readOnly = value;
}
/**
* Returns the transaction isolation property for this
* RowSet
object's connection. This property represents
* the transaction isolation level requested for use in transactions.
* RowSet
implementations such as
* the CachedRowSet
that operate in a disconnected environment,
* the SyncProvider
object
* offers complementary locking and data integrity options. The
* options described below are pertinent only to connected RowSet
* objects (JdbcRowSet
objects).
*
* @return one of the following constants:
* Connection.TRANSACTION_NONE
,
* Connection.TRANSACTION_READ_UNCOMMITTED
,
* Connection.TRANSACTION_READ_COMMITTED
,
* Connection.TRANSACTION_REPEATABLE_READ
, or
* Connection.TRANSACTION_SERIALIZABLE
* @see javax.sql.rowset.spi.SyncFactory
* @see javax.sql.rowset.spi.SyncProvider
* @see #setTransactionIsolation
*/
public int getTransactionIsolation() {
return isolation;
};
/**
* Sets the transaction isolation property for this JDBC RowSet
object to the given
* constant. The DBMS will use this transaction isolation level for
* transactions if it can.
* RowSet
implementations such as
* the CachedRowSet
that operate in a disconnected environment,
* the SyncProvider
object being used
* offers complementary locking and data integrity options. The
* options described below are pertinent only to connected RowSet
* objects (JdbcRowSet
objects).
*
* @param level one of the following constants, listed in ascending order:
* Connection.TRANSACTION_NONE
,
* Connection.TRANSACTION_READ_UNCOMMITTED
,
* Connection.TRANSACTION_READ_COMMITTED
,
* Connection.TRANSACTION_REPEATABLE_READ
, or
* Connection.TRANSACTION_SERIALIZABLE
* @throws SQLException if the given parameter is not one of the Connection
* constants
* @see javax.sql.rowset.spi.SyncFactory
* @see javax.sql.rowset.spi.SyncProvider
* @see #getTransactionIsolation
*/
public void setTransactionIsolation(int level) throws SQLException {
if ((level != Connection.TRANSACTION_NONE) &&
(level != Connection.TRANSACTION_READ_COMMITTED) &&
(level != Connection.TRANSACTION_READ_UNCOMMITTED) &&
(level != Connection.TRANSACTION_REPEATABLE_READ) &&
(level != Connection.TRANSACTION_SERIALIZABLE))
{
throw new SQLException("Invalid transaction isolation set. Must " +
"be either " +
"Connection.TRANSACTION_NONE or " +
"Connection.TRANSACTION_READ_UNCOMMITTED or " +
"Connection.TRANSACTION_READ_COMMITTED or " +
"Connection.RRANSACTION_REPEATABLE_READ or " +
"Connection.TRANSACTION_SERIALIZABLE");
}
this.isolation = level;
}
/**
* Retrieves the type map associated with the Connection
* object for this RowSet
object.
* Connection
objects with an associated type map.
* This type map, which is initially empty, can contain one or more
* fully-qualified SQL names and Class
objects indicating
* the class to which the named SQL value will be mapped. The type mapping
* specified in the connection's type map is used for custom type mapping
* when no other type map supersedes it.
* java.util.Map
object that is the type map
* for this RowSet
object's connection
*/
public java.util.Mapjava.util.Map
object as the type map
* associated with the Connection
object for this
* RowSet
object. The custom mapping indicated in
* this type map will be used unless a different type map is explicitly
* supplied to a method, in which case the type map supplied will be used.
*
* @param map a java.util.Map
object that contains the
* mapping from SQL type names for user defined types (UDT) to classes in
* the Java programming language. Each entry in the Map
* object consists of the fully qualified SQL name of a UDT and the
* Class
object for the SQLData
implementation
* of that UDT. May be null
.
*/
public void setTypeMap(java.util.MapRowSet
object.
* This limit applies only to columns that hold values of the
* following types: BINARY
, VARBINARY
,
* LONGVARBINARY
, CHAR
, VARCHAR
,
* and LONGVARCHAR
. If the limit is exceeded, the excess
* data is silently discarded.
*
* @return an int
indicating the current maximum column size
* limit; zero means that there is no limit
* @throws SQLException if an error occurs internally determining the
* maximum limit of the column size
*/
public int getMaxFieldSize() throws SQLException {
return maxFieldSize;
}
/**
* Sets the maximum number of bytes that can be used for a column
* value in this RowSet
object to the given number.
* This limit applies only to columns that hold values of the
* following types: BINARY
, VARBINARY
,
* LONGVARBINARY
, CHAR
, VARCHAR
,
* and LONGVARCHAR
. If the limit is exceeded, the excess
* data is silently discarded. For maximum portability, it is advisable to
* use values greater than 256.
*
* @param max an int
indicating the new maximum column size
* limit; zero means that there is no limit
* @throws SQLException if (1) an error occurs internally setting the
* maximum limit of the column size or (2) a size of less than 0 is set
*/
public void setMaxFieldSize(int max) throws SQLException {
if (max < 0) {
throw new SQLException("Invalid max field size set. Cannot be of " +
"value: " + max);
}
maxFieldSize = max;
}
/**
* Retrieves the maximum number of rows that this RowSet
object may contain. If
* this limit is exceeded, the excess rows are silently dropped.
*
* @return an int
indicating the current maximum number of
* rows; zero means that there is no limit
* @throws SQLException if an error occurs internally determining the
* maximum limit of rows that a Rowset
object can contain
*/
public int getMaxRows() throws SQLException {
return maxRows;
}
/**
* Sets the maximum number of rows that this RowSet
object may contain to
* the given number. If this limit is exceeded, the excess rows are
* silently dropped.
*
* @param max an int
indicating the current maximum number
* of rows; zero means that there is no limit
* @throws SQLException if an error occurs internally setting the
* maximum limit on the number of rows that a JDBC RowSet
object
* can contain; or if max is less than 0
; or
* if max is less than the fetchSize
of the
* RowSet
*/
public void setMaxRows(int max) throws SQLException {
if (max < 0) {
throw new SQLException("Invalid max row size set. Cannot be of " +
"value: " + max);
} else if (max < this.getFetchSize()) {
throw new SQLException("Invalid max row size set. Cannot be less " +
"than the fetchSize.");
}
this.maxRows = max;
}
/**
* Sets to the given boolean
whether or not the driver will
* scan for escape syntax and do escape substitution before sending SQL
* statements to the database. The default is for the driver to do escape
* processing.
* PreparedStatement
objects have usually been
* parsed prior to making this call, disabling escape processing for
* prepared statements will likely have no effect.
*
* @param enable true
to enable escape processing;
* false
to disable it
* @throws SQLException if an error occurs setting the underlying JDBC
* technology-enabled driver to process the escape syntax
*/
public void setEscapeProcessing(boolean enable) throws SQLException {
escapeProcessing = enable;
}
/**
* Retrieves the maximum number of seconds the driver will wait for a
* query to execute. If the limit is exceeded, an SQLException
* is thrown.
*
* @return the current query timeout limit in seconds; zero means that
* there is no limit
* @throws SQLException if an error occurs in determining the query
* time-out value
*/
public int getQueryTimeout() throws SQLException {
return queryTimeout;
}
/**
* Sets to the given number the maximum number of seconds the driver will
* wait for a query to execute. If the limit is exceeded, an
* SQLException
is thrown.
*
* @param seconds the new query time-out limit in seconds; zero means that
* there is no limit; must not be less than zero
* @throws SQLException if an error occurs setting the query
* time-out or if the query time-out value is less than 0
*/
public void setQueryTimeout(int seconds) throws SQLException {
if (seconds < 0) {
throw new SQLException("Invalid query timeout value set. Cannot be " +
"of value: " + seconds);
}
this.queryTimeout = seconds;
}
/**
* Retrieves a boolean
indicating whether rows marked
* for deletion appear in the set of current rows.
* The default value is false
.
* RowSet
object users
* can simply ignore this extra detail because only sophisticated
* applications will likely want to take advantage of this feature.
*
* @return true
if deleted rows are visible;
* false
otherwise
* @throws SQLException if an error occurs determining if deleted rows
* are visible or not
* @see #setShowDeleted
*/
public boolean getShowDeleted() throws SQLException {
return showDeleted;
}
/**
* Sets the property showDeleted
to the given
* boolean
value, which determines whether
* rows marked for deletion appear in the set of current rows.
*
* @param value true
if deleted rows should be shown;
* false
otherwise
* @throws SQLException if an error occurs setting whether deleted
* rows are visible or not
* @see #getShowDeleted
*/
public void setShowDeleted(boolean value) throws SQLException {
showDeleted = value;
}
/**
* Ascertains whether escape processing is enabled for this
* RowSet
object.
*
* @return true
if escape processing is turned on;
* false
otherwise
* @throws SQLException if an error occurs determining if escape
* processing is enabled or not or if the internal escape
* processing trigger has not been enabled
*/
public boolean getEscapeProcessing() throws SQLException {
return escapeProcessing;
}
/**
* Gives the driver a performance hint as to the direction in
* which the rows in this RowSet
object will be
* processed. The driver may ignore this hint.
* RowSet
object inherits the default properties of the
* ResultSet
object from which it got its data. That
* ResultSet
object's default fetch direction is set by
* the Statement
object that created it.
* RowSet
object only while it is
* connected to a database using a JDBC driver.
* RowSet
object may use this method at any time to change
* its setting for the fetch direction.
*
* @param direction one of ResultSet.FETCH_FORWARD
,
* ResultSet.FETCH_REVERSE
, or
* ResultSet.FETCH_UNKNOWN
* @throws SQLException if (1) the RowSet
type is
* TYPE_FORWARD_ONLY
and the given fetch direction is not
* FETCH_FORWARD
or (2) the given fetch direction is not
* one of the following:
* ResultSet.FETCH_FORWARD,
* ResultSet.FETCH_REVERSE, or
* ResultSet.FETCH_UNKNOWN
* @see #getFetchDirection
*/
public void setFetchDirection(int direction) throws SQLException {
// Changed the condition checking to the below as there were two
// conditions that had to be checked
// 1. RowSet is TYPE_FORWARD_ONLY and direction is not FETCH_FORWARD
// 2. Direction is not one of the valid values
if (((getType() == ResultSet.TYPE_FORWARD_ONLY) && (direction != ResultSet.FETCH_FORWARD)) ||
((direction != ResultSet.FETCH_FORWARD) &&
(direction != ResultSet.FETCH_REVERSE) &&
(direction != ResultSet.FETCH_UNKNOWN))) {
throw new SQLException("Invalid Fetch Direction");
}
fetchDir = direction;
}
/**
* Retrieves this RowSet
object's current setting for the
* fetch direction. The default type is ResultSet.FETCH_FORWARD
*
* @return one of ResultSet.FETCH_FORWARD
,
* ResultSet.FETCH_REVERSE
, or
* ResultSet.FETCH_UNKNOWN
* @throws SQLException if an error occurs in determining the
* current fetch direction for fetching rows
* @see #setFetchDirection
*/
public int getFetchDirection() throws SQLException {
//Added the following code to throw a
//SQL Exception if the fetchDir is not
//set properly.Bug id:4914155
// This checking is not necessary!
/*
if((fetchDir != ResultSet.FETCH_FORWARD) &&
(fetchDir != ResultSet.FETCH_REVERSE) &&
(fetchDir != ResultSet.FETCH_UNKNOWN)) {
throw new SQLException("Fetch Direction Invalid");
}
*/
return (fetchDir);
}
/**
* Sets the fetch size for this RowSet
object to the given number of
* rows. The fetch size gives a JDBC technology-enabled driver ("JDBC driver")
* a hint as to the
* number of rows that should be fetched from the database when more rows
* are needed for this RowSet
object. If the fetch size specified
* is zero, the driver ignores the value and is free to make its own best guess
* as to what the fetch size should be.
* RowSet
object inherits the default properties of the
* ResultSet
object from which it got its data. That
* ResultSet
object's default fetch size is set by
* the Statement
object that created it.
* RowSet
object only while it is
* connected to a database using a JDBC driver.
* For connected RowSet
implementations such as
* JdbcRowSet
, this method has a direct and immediate effect
* on the underlying JDBC driver.
* RowSet
object may use this method at any time to change
* its setting for the fetch size.
* RowSet
implementations such as
* CachedRowSet
, which operate in a disconnected environment,
* the SyncProvider
object being used
* may leverage the fetch size to poll the data source and
* retrieve a number of rows that do not exceed the fetch size and that may
* form a subset of the actual rows returned by the original query. This is
* an implementation variance determined by the specific SyncProvider
* object employed by the disconnected RowSet
object.
* 0
to let the
* driver decide what the best fetch size is; must not be less
* than 0
or more than the maximum number of rows
* allowed for this RowSet
object (the number returned
* by a call to the method {@link #getMaxRows})
* @throws SQLException if the specified fetch size is less than 0
* or more than the limit for the maximum number of rows
* @see #getFetchSize
*/
public void setFetchSize(int rows) throws SQLException {
//Added this checking as maxRows can be 0 when this function is called
//maxRows = 0 means rowset can hold any number of rows, os this checking
// is needed to take care of this condition.
if (getMaxRows() == 0 && rows >= 0) {
fetchSize = rows;
return;
}
if ((rows < 0) || (rows > getMaxRows())) {
throw new SQLException("Invalid fetch size set. Cannot be of " +
"value: " + rows);
}
fetchSize = rows;
}
/**
* Returns the fetch size for this RowSet
object. The default
* value is zero.
*
* @return the number of rows suggested as the fetch size when this RowSet
object
* needs more rows from the database
* @throws SQLException if an error occurs determining the number of rows in the
* current fetch size
* @see #setFetchSize
*/
public int getFetchSize() throws SQLException {
return fetchSize;
}
/**
* Returns the concurrency for this RowSet
object.
* The default is CONCUR_UPDATABLE
for both connected and
* disconnected RowSet
objects.
* setConcurrency
at any time
* to change a RowSet
object's concurrency.
* RowSet
* object, which must be one of the following:
* ResultSet.CONCUR_READ_ONLY
or
* ResultSet.CONCUR_UPDATABLE
* @throws SQLException if an error occurs getting the concurrency
* of this RowSet
object
* @see #setConcurrency
* @see #isReadOnly
*/
public int getConcurrency() throws SQLException {
return concurrency;
}
//-----------------------------------------------------------------------
// Parameters
//-----------------------------------------------------------------------
/**
* Checks the given index to see whether it is less than 1
and
* throws an SQLException
object if it is.
* int
indicating which parameter is to be
* checked; the first parameter is 1
* @throws SQLException if the parameter is less than 1
*/
private void checkParamIndex(int idx) throws SQLException {
if ((idx < 1)) {
throw new SQLException("Invalid Parameter Index");
}
}
//---------------------------------------------------------------------
// setter methods for setting the parameters in a RowSet
object's command
//---------------------------------------------------------------------
/**
* Sets the designated parameter to SQL NULL
.
* Note that the parameter's SQL type must be specified using one of the
* type codes defined in java.sql.Types
. This SQL type is
* specified in the second parameter.
* NULL
. Some DBMSs require this information, so it is required
* in order to make code more portable.
* RowSet
* object's command when the method execute
is called.
* Methods such as execute
and populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
* JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
* getParams
after this version of
* setNull
* has been called will return an Object
array containing the parameter values that
* have been set. In that array, the element that represents the values
* set with this method will itself be an array. The first element of that array
* is null
.
* The second element is the value set for sqlType.
* The parameter number is indicated by an element's position in the array
* returned by the method getParams
,
* with the first element being the value for the first placeholder parameter, the
* second element being the value for the second placeholder parameter, and so on.
* In other words, if the second placeholder parameter is being set to
* null
, the array containing it will be the second element in
* the array returned by getParams
.
* RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param sqlType an int
that is one of the SQL type codes
* defined in the class {@link java.sql.Types}. If a non-standard
* sqlType is supplied, this method will not throw a
* SQLException
. This allows implicit support for
* non-standard SQL types.
* @throws SQLException if a database access error occurs or the given
* parameter index is out of bounds
* @see #getParams
*/
public void setNull(int parameterIndex, int sqlType) throws SQLException {
Object nullVal[];
checkParamIndex(parameterIndex);
nullVal = new Object[2];
nullVal[0] = null;
nullVal[1] = Integer.valueOf(sqlType);
if (params == null){
throw new SQLException("Set initParams() before setNull");
}
params.put(Integer.valueOf(parameterIndex - 1), nullVal);
}
/**
* Sets the designated parameter to SQL NULL
.
*
* Although this version of the method setNull
is intended
* for user-defined
* and REF
parameters, this method may be used to set a null
* parameter for any JDBC type. The following are user-defined types:
* STRUCT
, DISTINCT
, and JAVA_OBJECT
,
* and named array types.
*
* 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 technology-enabled
* driver does not need the type code or type name information,
* it may ignore it.
* REF
type,
* the given typeName
parameter is ignored.
* RowSet
* object's command when the method execute
is called.
* Methods such as execute
and populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
* JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
* getParams
after this version of
* setNull
* has been called will return an Object
array containing the parameter values that
* have been set. In that array, the element that represents the values
* set with this method will itself be an array. The first element of that array
* is null
.
* The second element is the value set for sqlType, and the third
* element is the value set for typeName.
* The parameter number is indicated by an element's position in the array
* returned by the method getParams
,
* with the first element being the value for the first placeholder parameter, the
* second element being the value for the second placeholder parameter, and so on.
* In other words, if the second placeholder parameter is being set to
* null
, the array containing it will be the second element in
* the array returned by getParams
.
* RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param sqlType a value from java.sql.Types
* @param typeName the fully qualified name of an SQL user-defined type,
* which is ignored if the parameter is not a user-defined
* type or REF
value
* @throws SQLException if an error occurs or the given parameter index
* is out of bounds
* @see #getParams
*/
public void setNull(int parameterIndex, int sqlType, String typeName)
throws SQLException {
Object nullVal[];
checkParamIndex(parameterIndex);
nullVal = new Object[3];
nullVal[0] = null;
nullVal[1] = Integer.valueOf(sqlType);
nullVal[2] = typeName;
if(params == null){
throw new SQLException("Set initParams() before setNull");
}
params.put(Integer.valueOf(parameterIndex - 1), nullVal);
}
/**
* Sets the designated parameter to the given boolean
in the
* Java programming language. The driver converts this to an SQL
* BIT
value when it sends it to the database.
* RowSet
* object's command when the method execute
is called.
* Methods such as execute
, populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
* JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param x the parameter value
* @throws SQLException if an error occurs or the
* parameter index is out of bounds
* @see #getParams
*/
public void setBoolean(int parameterIndex, boolean x) throws SQLException {
checkParamIndex(parameterIndex);
if(params == null){
throw new SQLException("Set initParams() before setNull");
}
params.put(Integer.valueOf(parameterIndex - 1), Boolean.valueOf(x));
}
/**
* Sets the designated parameter to the given byte
in the Java
* programming language. The driver converts this to an SQL
* TINYINT
value when it sends it to the database.
* RowSet
* object's command when the method execute
is called.
* Methods such as execute
and populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
* JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param x the parameter value
* @throws SQLException if an error occurs or the
* parameter index is out of bounds
* @see #getParams
*/
public void setByte(int parameterIndex, byte x) throws SQLException {
checkParamIndex(parameterIndex);
if(params == null){
throw new SQLException("Set initParams() before setByte");
}
params.put(Integer.valueOf(parameterIndex - 1), Byte.valueOf(x));
}
/**
* Sets the designated parameter to the given short
in the
* Java programming language. The driver converts this to an SQL
* SMALLINT
value when it sends it to the database.
* RowSet
* object's command when the method execute
is called.
* Methods such as execute
and populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
* JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
* RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param x the parameter value
* @throws SQLException if an error occurs or the
* parameter index is out of bounds
* @see #getParams
*/
public void setShort(int parameterIndex, short x) throws SQLException {
checkParamIndex(parameterIndex);
if(params == null){
throw new SQLException("Set initParams() before setShort");
}
params.put(Integer.valueOf(parameterIndex - 1), Short.valueOf(x));
}
/**
* Sets the designated parameter to an int
in the Java
* programming language. The driver converts this to an SQL
* INTEGER
value when it sends it to the database.
* RowSet
* object's command when the method execute
is called.
* Methods such as execute
and populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
* JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param x the parameter value
* @throws SQLException if an error occurs or the
* parameter index is out of bounds
* @see #getParams
*/
public void setInt(int parameterIndex, int x) throws SQLException {
checkParamIndex(parameterIndex);
if(params == null){
throw new SQLException("Set initParams() before setInt");
}
params.put(Integer.valueOf(parameterIndex - 1), Integer.valueOf(x));
}
/**
* Sets the designated parameter to the given long
in the Java
* programming language. The driver converts this to an SQL
* BIGINT
value when it sends it to the database.
* RowSet
* object's command when the method execute
is called.
* Methods such as execute
and populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
* JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param x the parameter value
* @throws SQLException if an error occurs or the
* parameter index is out of bounds
* @see #getParams
*/
public void setLong(int parameterIndex, long x) throws SQLException {
checkParamIndex(parameterIndex);
if(params == null){
throw new SQLException("Set initParams() before setLong");
}
params.put(Integer.valueOf(parameterIndex - 1), Long.valueOf(x));
}
/**
* Sets the designated parameter to the given float
in the
* Java programming language. The driver converts this to an SQL
* FLOAT
value when it sends it to the database.
* RowSet
* object's command when the method execute
is called.
* Methods such as execute
and populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
* JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param x the parameter value
* @throws SQLException if an error occurs or the
* parameter index is out of bounds
* @see #getParams
*/
public void setFloat(int parameterIndex, float x) throws SQLException {
checkParamIndex(parameterIndex);
if(params == null){
throw new SQLException("Set initParams() before setFloat");
}
params.put(Integer.valueOf(parameterIndex - 1), new Float(x));
}
/**
* Sets the designated parameter to the given double
in the
* Java programming language. The driver converts this to an SQL
* DOUBLE
value when it sends it to the database.
* RowSet
* object's command when the method execute
is called.
* Methods such as execute
and populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
* JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
* S
* @param parameterIndex the ordinal number of the placeholder parameter
* in this RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param x the parameter value
* @throws SQLException if an error occurs or the
* parameter index is out of bounds
* @see #getParams
*/
public void setDouble(int parameterIndex, double x) throws SQLException {
checkParamIndex(parameterIndex);
if(params == null){
throw new SQLException("Set initParams() before setDouble");
}
params.put(Integer.valueOf(parameterIndex - 1), new Double(x));
}
/**
* Sets the designated parameter to the given
* java.lang.BigDecimal
value. The driver converts this to
* an SQL NUMERIC
value when it sends it to the database.
* RowSet
* object's command when the method execute
is called.
* Methods such as execute
and populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
* JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param x the parameter value
* @throws SQLException if an error occurs or the
* parameter index is out of bounds
* @see #getParams
*/
public void setBigDecimal(int parameterIndex, java.math.BigDecimal x) throws SQLException {
checkParamIndex(parameterIndex);
if(params == null){
throw new SQLException("Set initParams() before setBigDecimal");
}
params.put(Integer.valueOf(parameterIndex - 1), x);
}
/**
* Sets the designated parameter to the given 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.
* RowSet
* object's command when the method execute
is called.
* Methods such as execute
and populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
* JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
* RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param x the parameter value
* @throws SQLException if an error occurs or the
* parameter index is out of bounds
* @see #getParams
*/
public void setString(int parameterIndex, String x) throws SQLException {
checkParamIndex(parameterIndex);
if(params == null){
throw new SQLException("Set initParams() before setString");
}
params.put(Integer.valueOf(parameterIndex - 1), x);
}
/**
* Sets the designated parameter to the given array of bytes.
* The driver converts this to an SQL
* VARBINARY
or LONGVARBINARY
value
* (depending on the argument's size relative to the driver's limits
* on VARBINARY
values) when it sends it to the database.
* RowSet
* object's command when the method execute
is called.
* Methods such as execute
and populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
* JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param x the parameter value
* @throws SQLException if an error occurs or the
* parameter index is out of bounds
* @see #getParams
*/
public void setBytes(int parameterIndex, byte x[]) throws SQLException {
checkParamIndex(parameterIndex);
if(params == null){
throw new SQLException("Set initParams() before setBytes");
}
params.put(Integer.valueOf(parameterIndex - 1), x);
}
/**
* Sets the designated parameter to the given java.sql.Date
* value. The driver converts this to an SQL
* DATE
value when it sends it to the database.
* RowSet
* object's command when the method execute
is called.
* Methods such as execute
and populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
* JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
* getParams
after this version
* of setDate
* has been called will return an array with the value to be set for
* placeholder parameter number parameterIndex being the Date
* object supplied as the second parameter.
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* parameterIndex is parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param x the parameter value
* @throws SQLException if an error occurs or the
* parameter index is out of bounds
* @see #getParams
*/
public void setDate(int parameterIndex, java.sql.Date x) throws SQLException {
checkParamIndex(parameterIndex);
if(params == null){
throw new SQLException("Set initParams() before setDate");
}
params.put(Integer.valueOf(parameterIndex - 1), x);
}
/**
* Sets the designated parameter to the given java.sql.Time
* value. The driver converts this to an SQL TIME
value
* when it sends it to the database.
* RowSet
* object's command when the method execute
is called.
* Methods such as execute
and populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
* JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
* getParams
after this version
* of the method setTime
* has been called will return an array of the parameters that have been set.
* The parameter to be set for parameter placeholder number parameterIndex
* will be the Time
object that was set as the second parameter
* to this method.
* RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param x a java.sql.Time
object, which is to be set as the value
* for placeholder parameter parameterIndex
* @throws SQLException if an error occurs or the
* parameter index is out of bounds
* @see #getParams
*/
public void setTime(int parameterIndex, java.sql.Time x) throws SQLException {
checkParamIndex(parameterIndex);
if(params == null){
throw new SQLException("Set initParams() before setTime");
}
params.put(Integer.valueOf(parameterIndex - 1), x);
}
/**
* Sets the designated parameter to the given
* java.sql.Timestamp
value.
* The driver converts this to an SQL TIMESTAMP
value when it
* sends it to the database.
* RowSet
* object's command when the method execute
is called.
* Methods such as execute
and populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
* JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
* getParams
after this version of
* setTimestamp
* has been called will return an array with the value for parameter placeholder
* number parameterIndex being the Timestamp
object that was
* supplied as the second parameter to this method.
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* parameterIndex is parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param x a java.sql.Timestamp
object
* @throws SQLException if an error occurs or the
* parameter index is out of bounds
* @see #getParams
*/
public void setTimestamp(int parameterIndex, java.sql.Timestamp x) throws SQLException {
checkParamIndex(parameterIndex);
if(params == null){
throw new SQLException("Set initParams() before setTimestamp");
}
params.put(Integer.valueOf(parameterIndex - 1), x);
}
/**
* Sets the designated parameter to the given
* java.io.InputStream
object,
* which will have the specified number of bytes.
* The contents of the stream will be read and sent to the database.
* This method throws an SQLException
object if the number of bytes
* read and sent to the database is not equal to length.
* LONGVARCHAR
* parameter, it may be more practical to send it via a
* java.io.InputStream
object. A JDBC technology-enabled
* driver will read the data from the stream as needed until it reaches
* end-of-file. The driver will do any necessary conversion from ASCII to
* the database CHAR
format.
*
* RowSet
* object's command when the method execute
is called.
* Methods such as execute
and populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
* JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
* getParams
after setAsciiStream
* has been called will return an array containing the parameter values that
* have been set. The element in the array that represents the values
* set with this method will itself be an array. The first element of that array
* is the given java.io.InputStream
object.
* The second element is the value set for length.
* The third element is an internal BaseRowSet
constant
* specifying that the stream passed to this method is an ASCII stream.
* The parameter number is indicated by an element's position in the array
* returned by the method getParams
,
* with the first element being the value for the first placeholder parameter, the
* second element being the value for the second placeholder parameter, and so on.
* In other words, if the input stream being set is the value for the second
* placeholder parameter, the array containing it will be the second element in
* the array returned by getParams
.
* RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param x the Java input stream that contains the ASCII parameter value
* @param length the number of bytes in the stream. This is the number of bytes
* the driver will send to the DBMS; lengths of 0 or less are
* are undefined but will cause an invalid length exception to be
* thrown in the underlying JDBC driver.
* @throws SQLException if an error occurs, the parameter index is out of bounds,
* or when connected to a data source, the number of bytes the driver reads
* and sends to the database is not equal to the number of bytes specified
* in length
* @see #getParams
*/
public void setAsciiStream(int parameterIndex, java.io.InputStream x, int length) throws SQLException {
Object asciiStream[];
checkParamIndex(parameterIndex);
asciiStream = new Object[3];
asciiStream[0] = x;
asciiStream[1] = Integer.valueOf(length);
asciiStream[2] = Integer.valueOf(ASCII_STREAM_PARAM);
if(params == null){
throw new SQLException("Set initParams() before setAsciiStream");
}
params.put(Integer.valueOf(parameterIndex - 1), asciiStream);
}
/**
* Sets the designated parameter in this RowSet
object's command
* 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.
*
* setAsciiStream
which takes a length parameter.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the Java input stream that contains the ASCII parameter value
* @exception SQLException if a database access error occurs or
* this method is called on a closed PreparedStatement
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
* @since 1.6
*/
public void setAsciiStream(int parameterIndex, java.io.InputStream x)
throws SQLException {
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given java.io.InputStream
* object, which will have the specified number of bytes.
* The contents of the stream will be read and sent to the database.
* This method throws an SQLException
object if the number of bytes
* read and sent to the database is not equal to length.
* LONGVARBINARY
parameter, it may be more practical
* to send it via a java.io.InputStream
object.
* A JDBC technology-enabled driver will read the data from the
* stream as needed until it reaches end-of-file.
*
* RowSet
* object's command when the method execute
is called.
* Methods such as execute
and populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
*JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
* getParams
after setBinaryStream
* has been called will return an array containing the parameter values that
* have been set. In that array, the element that represents the values
* set with this method will itself be an array. The first element of that array
* is the given java.io.InputStream
object.
* The second element is the value set for length.
* The third element is an internal BaseRowSet
constant
* specifying that the stream passed to this method is a binary stream.
* The parameter number is indicated by an element's position in the array
* returned by the method getParams
,
* with the first element being the value for the first placeholder parameter, the
* second element being the value for the second placeholder parameter, and so on.
* In other words, if the input stream being set is the value for the second
* placeholder parameter, the array containing it will be the second element in
* the array returned by getParams
.
* RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param x the input stream that contains the binary value to be set
* @param length the number of bytes in the stream; lengths of 0 or less are
* are undefined but will cause an invalid length exception to be
* thrown in the underlying JDBC driver.
* @throws SQLException if an error occurs, the parameter index is out of bounds,
* or when connected to a data source, the number of bytes the driver
* reads and sends to the database is not equal to the number of bytes
* specified in length
* @see #getParams
*/
public void setBinaryStream(int parameterIndex, java.io.InputStream x, int length) throws SQLException {
Object binaryStream[];
checkParamIndex(parameterIndex);
binaryStream = new Object[3];
binaryStream[0] = x;
binaryStream[1] = Integer.valueOf(length);
binaryStream[2] = Integer.valueOf(BINARY_STREAM_PARAM);
if(params == null){
throw new SQLException("Set initParams() before setBinaryStream");
}
params.put(Integer.valueOf(parameterIndex - 1), binaryStream);
}
/**
* Sets the designated parameter in this RowSet
object's command
* 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.
*
* setBinaryStream
which takes a length parameter.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the java input stream which contains the binary parameter value
* @exception SQLException if a database access error occurs or
* this method is called on a closed PreparedStatement
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
* @since 1.6
*/
public void setBinaryStream(int parameterIndex, java.io.InputStream x)
throws SQLException {
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given
* java.io.InputStream
object, which will have the specified
* number of bytes. The contents of the stream will be read and sent
* to the database.
* This method throws an SQLException
if the number of bytes
* read and sent to the database is not equal to length.
* LONGVARCHAR
parameter, it may be more practical
* to send it via a java.io.InputStream
object.
* A JDBC technology-enabled driver will read the data from the
* stream as needed, until it reaches end-of-file.
* The 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.
*
* getCharacterStream
* should be used in its place.
* RowSet
* object's command when the method execute
is called.
* Calls made to the method getParams
after setUnicodeStream
* has been called will return an array containing the parameter values that
* have been set. In that array, the element that represents the values
* set with this method will itself be an array. The first element of that array
* is the given java.io.InputStream
object.
* The second element is the value set for length.
* The third element is an internal BaseRowSet
constant
* specifying that the stream passed to this method is a Unicode stream.
* The parameter number is indicated by an element's position in the array
* returned by the method getParams
,
* with the first element being the value for the first placeholder parameter, the
* second element being the value for the second placeholder parameter, and so on.
* In other words, if the input stream being set is the value for the second
* placeholder parameter, the array containing it will be the second element in
* the array returned by getParams
.
* RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param x the java.io.InputStream
object that contains the
* UNICODE parameter value
* @param length the number of bytes in the input stream
* @throws SQLException if an error occurs, the parameter index is out of bounds,
* or the number of bytes the driver reads and sends to the database is
* not equal to the number of bytes specified in length
* @deprecated getCharacterStream should be used in its place
* @see #getParams
*/
public void setUnicodeStream(int parameterIndex, java.io.InputStream x, int length) throws SQLException {
Object unicodeStream[];
checkParamIndex(parameterIndex);
unicodeStream = new Object[3];
unicodeStream[0] = x;
unicodeStream[1] = Integer.valueOf(length);
unicodeStream[2] = Integer.valueOf(UNICODE_STREAM_PARAM);
if(params == null){
throw new SQLException("Set initParams() before setUnicodeStream");
}
params.put(Integer.valueOf(parameterIndex - 1), unicodeStream);
}
/**
* Sets the designated parameter to the given java.io.Reader
* object, which will have the specified number of characters. The
* contents of the reader will be read and sent to the database.
* This method throws an SQLException
if the number of bytes
* read and sent to the database is not equal to length.
* LONGVARCHAR
parameter, it may be more practical
* to send it via a Reader
object.
* A JDBC technology-enabled driver will read the data from the
* stream as needed until it reaches end-of-file.
* The 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.
*
* RowSet
* object's command when the method execute
is called.
* Methods such as execute
and populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
* JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
* getParams
after
* setCharacterStream
* has been called will return an array containing the parameter values that
* have been set. In that array, the element that represents the values
* set with this method will itself be an array. The first element of that array
* is the given java.io.Reader
object.
* The second element is the value set for length.
* The parameter number is indicated by an element's position in the array
* returned by the method getParams
,
* with the first element being the value for the first placeholder parameter, the
* second element being the value for the second placeholder parameter, and so on.
* In other words, if the reader being set is the value for the second
* placeholder parameter, the array containing it will be the second element in
* the array returned by getParams
.
* RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param reader the Reader
object that contains the
* Unicode data
* @param length the number of characters in the stream; lengths of 0 or
* less are undefined but will cause an invalid length exception to
* be thrown in the underlying JDBC driver.
* @throws SQLException if an error occurs, the parameter index is out of bounds,
* or when connected to a data source, the number of bytes the driver
* reads and sends to the database is not equal to the number of bytes
* specified in length
* @see #getParams
*/
public void setCharacterStream(int parameterIndex, Reader reader, int length) throws SQLException {
Object charStream[];
checkParamIndex(parameterIndex);
charStream = new Object[2];
charStream[0] = reader;
charStream[1] = Integer.valueOf(length);
if(params == null){
throw new SQLException("Set initParams() before setCharacterStream");
}
params.put(Integer.valueOf(parameterIndex - 1), charStream);
}
/**
* Sets the designated parameter in this RowSet
object's command
* 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.
*
* setCharacterStream
which takes a length parameter.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param reader the java.io.Reader
object that contains the
* Unicode data
* @exception SQLException if a database access error occurs or
* this method is called on a closed PreparedStatement
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
* @since 1.6
*/
public void setCharacterStream(int parameterIndex,
java.io.Reader reader) throws SQLException {
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to an Object
in the Java
* programming language. The second parameter must be an
* Object
type. For integral values, the
* java.lang
equivalent
* objects should be used. For example, use the class Integer
* for an int
.
* SQLData
), the driver should call the method
* SQLData.writeSQL
to write the object 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.
* RowSet
execute is called.
* Methods such as execute
and populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
* JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
* getParams
after this version of
* setObject
* has been called will return an array containing the parameter values that
* have been set. In that array, the element that represents the values
* set with this method will itself be an array. The first element of that array
* is the given Object
instance, and the
* second element is the value set for targetSqlType. The
* third element is the value set for scale, which the driver will
* ignore if the type of the object being set is not
* java.sql.Types.NUMERIC
or java.sql.Types.DECIMAL
.
* The parameter number is indicated by an element's position in the array
* returned by the method getParams
,
* with the first element being the value for the first placeholder parameter, the
* second element being the value for the second placeholder parameter, and so on.
* In other words, if the object being set is the value for the second
* placeholder parameter, the array containing it will be the second element in
* the array returned by getParams
.
*RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param x the Object
containing the input parameter value;
* must be an Object
type
* @param targetSqlType the SQL type (as defined in java.sql.Types
)
* to be sent to the database. The scale
argument may
* further qualify this type. If a non-standard targetSqlType
* is supplied, this method will not throw a SQLException
.
* This allows implicit support for non-standard SQL types.
* @param scale for the types java.sql.Types.DECIMAL
and
* java.sql.Types.NUMERIC
, this is the number
* of digits after the decimal point. For all other types, this
* value will be ignored.
* @throws SQLException if an error occurs or the parameter index is out of bounds
* @see #getParams
*/
public void setObject(int parameterIndex, Object x, int targetSqlType, int scale) throws SQLException {
Object obj[];
checkParamIndex(parameterIndex);
obj = new Object[3];
obj[0] = x;
obj[1] = Integer.valueOf(targetSqlType);
obj[2] = Integer.valueOf(scale);
if(params == null){
throw new SQLException("Set initParams() before setObject");
}
params.put(Integer.valueOf(parameterIndex - 1), obj);
}
/**
* Sets the value of the designated parameter with the given
* Object
value.
* This method is like setObject(int parameterIndex, Object x, int
* targetSqlType, int scale)
except that it assumes a scale of zero.
* RowSet
* object's command when the method execute
is called.
* Methods such as execute
and populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
* JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
* getParams
after this version of
* setObject
* has been called will return an array containing the parameter values that
* have been set. In that array, the element that represents the values
* set with this method will itself be an array. The first element of that array
* is the given Object
instance.
* The second element is the value set for targetSqlType.
* The parameter number is indicated by an element's position in the array
* returned by the method getParams
,
* with the first element being the value for the first placeholder parameter, the
* second element being the value for the second placeholder parameter, and so on.
* In other words, if the object being set is the value for the second
* placeholder parameter, the array containing it will be the second element in
* the array returned by getParams
.
* RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param x the Object
containing the input parameter value;
* must be an Object
type
* @param targetSqlType the SQL type (as defined in java.sql.Types
)
* to be sent to the database. If a non-standard targetSqlType
* is supplied, this method will not throw a SQLException
.
* This allows implicit support for non-standard SQL types.
* @throws SQLException if an error occurs or the parameter index
* is out of bounds
* @see #getParams
*/
public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
Object obj[];
checkParamIndex(parameterIndex);
obj = new Object[2];
obj[0] = x;
obj[1] = Integer.valueOf(targetSqlType);
if (params == null){
throw new SQLException("Set initParams() before setObject");
}
params.put(Integer.valueOf(parameterIndex - 1), obj);
}
/**
* Sets the designated parameter to an Object
in the Java
* programming language. The second parameter must be an
* Object
* type. For integral values, the java.lang
equivalent
* objects should be used. For example, use the class Integer
* for an int
.
* Object
types to SQL types. The driver will
* use this standard mapping to convert the given object
* to its corresponding SQL type before sending it to the database.
* If the object has a custom mapping (is of a class implementing
* SQLData
), the driver should call the method
* SQLData.writeSQL
to write the object to the SQL
* data stream.
* Ref
, Blob
, Clob
,
* Struct
, or Array
,
* the driver should pass it to the database as a value of the
* corresponding SQL type.
* RowSet
* object's command when the method execute
is called.
* Methods such as execute
and populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
* JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
* getParams
* will return an object array of the current command parameters, which will
* include the Object
set for placeholder parameter number
* parameterIndex
.
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* parameterIndex is element number parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param x the object containing the input parameter value
* @throws SQLException if an error occurs the
* parameter index is out of bounds, or there
* is ambiguity in the implementation of the
* object being set
* @see #getParams
*/
public void setObject(int parameterIndex, Object x) throws SQLException {
checkParamIndex(parameterIndex);
if (params == null) {
throw new SQLException("Set initParams() before setObject");
}
params.put(Integer.valueOf(parameterIndex - 1), x);
}
/**
* Sets the designated parameter to the given Ref
object in
* the Java programming language. The driver converts this to an SQL
* REF
value when it sends it to the database. Internally, the
* Ref
is represented as a SerialRef
to ensure
* serializability.
* RowSet
* object's command when the method execute
is called.
* Methods such as execute
and populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
* JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
* getParams
* will return an object array of the current command parameters, which will
* include the Ref
object set for placeholder parameter number
* parameterIndex
.
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* parameterIndex is element number parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param ref a Ref
object representing an SQL REF
* value; cannot be null
* @throws SQLException if an error occurs; the parameter index is out of
* bounds or the Ref
object is null
; or
* the Ref
object returns a null
base type
* name.
* @see #getParams
* @see javax.sql.rowset.serial.SerialRef
*/
public void setRef (int parameterIndex, Ref ref) throws SQLException {
checkParamIndex(parameterIndex);
if (params == null) {
throw new SQLException("Set initParams() before setRef");
}
params.put(Integer.valueOf(parameterIndex - 1), new SerialRef(ref));
}
/**
* Sets the designated parameter to the given Blob
object in
* the Java programming language. The driver converts this to an SQL
* BLOB
value when it sends it to the database. Internally,
* the Blob
is represented as a SerialBlob
* to ensure serializability.
* RowSet
* object's command when the method execute
is called.
* Methods such as execute
and populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
* NOTE: JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
* getParams
* will return an object array of the current command parameters, which will
* include the Blob
object set for placeholder parameter number
* parameterIndex
.
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* parameterIndex is element number parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param x a Blob
object representing an SQL
* BLOB
value
* @throws SQLException if an error occurs or the
* parameter index is out of bounds
* @see #getParams
* @see javax.sql.rowset.serial.SerialBlob
*/
public void setBlob (int parameterIndex, Blob x) throws SQLException {
checkParamIndex(parameterIndex);
if(params == null){
throw new SQLException("Set initParams() before setBlob");
}
params.put(Integer.valueOf(parameterIndex - 1), new SerialBlob(x));
}
/**
* Sets the designated parameter to the given Clob
object in
* the Java programming language. The driver converts this to an SQL
* CLOB
value when it sends it to the database. Internally, the
* Clob
is represented as a SerialClob
to ensure
* serializability.
* RowSet
* object's command when the method execute
is called.
* Methods such as execute
and populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
* JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
* getParams
* will return an object array of the current command parameters, which will
* include the Clob
object set for placeholder parameter number
* parameterIndex
.
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* parameterIndex is element number parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param x a Clob
object representing an SQL
* CLOB
value; cannot be null
* @throws SQLException if an error occurs; the parameter index is out of
* bounds or the Clob
is null
* @see #getParams
* @see javax.sql.rowset.serial.SerialBlob
*/
public void setClob (int parameterIndex, Clob x) throws SQLException {
checkParamIndex(parameterIndex);
if(params == null){
throw new SQLException("Set initParams() before setClob");
}
params.put(Integer.valueOf(parameterIndex - 1), new SerialClob(x));
}
/**
* Sets the designated parameter to an Array
object in the
* Java programming language. The driver converts this to an SQL
* ARRAY
value when it sends it to the database. Internally,
* the Array
is represented as a SerialArray
* to ensure serializability.
* RowSet
* object's command when the method execute
is called.
* Methods such as execute
and populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
* JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
* getParams
* will return an object array of the current command parameters, which will
* include the Array
object set for placeholder parameter number
* parameterIndex
.
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* parameterIndex is element number parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param array an Array
object representing an SQL
* ARRAY
value; cannot be null. The Array
object
* passed to this method must return a non-null Object for all
* getArray()
method calls. A null value will cause a
* SQLException
to be thrown.
* @throws SQLException if an error occurs; the parameter index is out of
* bounds or the ARRAY
is null
* @see #getParams
* @see javax.sql.rowset.serial.SerialArray
*/
public void setArray (int parameterIndex, Array array) throws SQLException {
checkParamIndex(parameterIndex);
if (params == null){
throw new SQLException("Set initParams() before setArray");
}
params.put(Integer.valueOf(parameterIndex - 1), new SerialArray(array));
}
/**
* Sets the designated parameter to the given java.sql.Date
* object.
* When the DBMS does not store time zone information, the driver will use
* the given Calendar
object to construct the SQL DATE
* value to send to the database. With a
* Calendar
object, the driver can calculate the date
* taking into account a custom time zone. If no Calendar
* object is specified, the driver uses the time zone of the Virtual Machine
* that is running the application.
* RowSet
* object's command when the method execute
is called.
* Methods such as execute
and populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
* JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
* getParams
after this version of
* setDate
* has been called will return an array containing the parameter values that
* have been set. In that array, the element that represents the values
* set with this method will itself be an array. The first element of that array
* is the given java.sql.Date
object.
* The second element is the value set for cal.
* The parameter number is indicated by an element's position in the array
* returned by the method getParams
,
* with the first element being the value for the first placeholder parameter, the
* second element being the value for the second placeholder parameter, and so on.
* In other words, if the date being set is the value for the second
* placeholder parameter, the array containing it will be the second element in
* the array returned by getParams
.
* RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param x a java.sql.Date
object representing an SQL
* DATE
value
* @param cal a java.util.Calendar
object to use when
* when constructing the date
* @throws SQLException if an error occurs or the
* parameter index is out of bounds
* @see #getParams
*/
public void setDate(int parameterIndex, java.sql.Date x, Calendar cal) throws SQLException {
Object date[];
checkParamIndex(parameterIndex);
date = new Object[2];
date[0] = x;
date[1] = cal;
if(params == null){
throw new SQLException("Set initParams() before setDate");
}
params.put(Integer.valueOf(parameterIndex - 1), date);
}
/**
* Sets the designated parameter to the given java.sql.Time
* object. The driver converts this
* to an SQL TIME
value when it sends it to the database.
* Calendar
object to construct the SQL TIME
* value to send to the database. With a
* Calendar
object, the driver can calculate the date
* taking into account a custom time zone. If no Calendar
* object is specified, the driver uses the time zone of the Virtual Machine
* that is running the application.
* RowSet
* object's command when the method execute
is called.
* Methods such as execute
and populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
* JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
* getParams
after this version of
* setTime
* has been called will return an array containing the parameter values that
* have been set. In that array, the element that represents the values
* set with this method will itself be an array. The first element of that array
* is the given java.sql.Time
object.
* The second element is the value set for cal.
* The parameter number is indicated by an element's position in the array
* returned by the method getParams
,
* with the first element being the value for the first placeholder parameter, the
* second element being the value for the second placeholder parameter, and so on.
* In other words, if the time being set is the value for the second
* placeholder parameter, the array containing it will be the second element in
* the array returned by getParams
.
* RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param x a java.sql.Time
object
* @param cal the java.util.Calendar
object the driver can use to
* construct the time
* @throws SQLException if an error occurs or the
* parameter index is out of bounds
* @see #getParams
*/
public void setTime(int parameterIndex, java.sql.Time x, Calendar cal) throws SQLException {
Object time[];
checkParamIndex(parameterIndex);
time = new Object[2];
time[0] = x;
time[1] = cal;
if(params == null){
throw new SQLException("Set initParams() before setTime");
}
params.put(Integer.valueOf(parameterIndex - 1), time);
}
/**
* Sets the designated parameter to the given
* java.sql.Timestamp
object. The driver converts this
* to an SQL TIMESTAMP
value when it sends it to the database.
* Calendar
object to construct the SQL TIMESTAMP
* value to send to the database. With a
* Calendar
object, the driver can calculate the timestamp
* taking into account a custom time zone. If no Calendar
* object is specified, the driver uses the time zone of the Virtual Machine
* that is running the application.
* RowSet
* object's command when the method execute
is called.
* Methods such as execute
and populate
must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 RowSet
interfaces.
* JdbcRowSet
does not require the populate
method
* as it is undefined in this class.
* getParams
after this version of
* setTimestamp
* has been called will return an array containing the parameter values that
* have been set. In that array, the element that represents the values
* set with this method will itself be an array. The first element of that array
* is the given java.sql.Timestamp
object.
* The second element is the value set for cal.
* The parameter number is indicated by an element's position in the array
* returned by the method getParams
,
* with the first element being the value for the first placeholder parameter, the
* second element being the value for the second placeholder parameter, and so on.
* In other words, if the timestamp being set is the value for the second
* placeholder parameter, the array containing it will be the second element in
* the array returned by getParams
.
* RowSet
object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* 1
or greater
* @param x a java.sql.Timestamp
object
* @param cal the java.util.Calendar
object the driver can use to
* construct the timestamp
* @throws SQLException if an error occurs or the
* parameter index is out of bounds
* @see #getParams
*/
public void setTimestamp(int parameterIndex, java.sql.Timestamp x, Calendar cal) throws SQLException {
Object timestamp[];
checkParamIndex(parameterIndex);
timestamp = new Object[2];
timestamp[0] = x;
timestamp[1] = cal;
if(params == null){
throw new SQLException("Set initParams() before setTimestamp");
}
params.put(Integer.valueOf(parameterIndex - 1), timestamp);
}
/**
* Clears all of the current parameter values in this RowSet
* object's internal representation of the parameters to be set in
* this RowSet
object's command when it is executed.
* RowSet
object's command. Setting a parameter value with the
* setter methods automatically clears the value of the
* designated parameter and replaces it with the new specified value.
* setCommand
* method to clear all of the parameters set for the previous command.
* initParams
* method in that it maintains the schema of the RowSet
object.
*
* @throws SQLException if an error occurs clearing the parameters
*/
public void clearParameters() throws SQLException {
params.clear();
}
/**
* Retrieves an array containing the parameter values (both Objects and
* primitives) that have been set for this
* RowSet
object's command and throws an SQLException
object
* if all parameters have not been set. Before the command is sent to the
* DBMS to be executed, these parameters will be substituted
* for placeholder parameters in the PreparedStatement
object
* that is the command for a RowSet
implementation extending
* the BaseRowSet
class.
* Object
instance
* that contains the values of the parameters supplied to a setter method.
* The order of the elements is determined by the value supplied for
* parameterIndex. If the setter method takes only the parameter index
* and the value to be set (possibly null), the array element will contain the value to be set
* (which will be expressed as an Object
). If there are additional
* parameters, the array element will itself be an array containing the value to be set
* plus any additional parameter values supplied to the setter method. If the method
* sets a stream, the array element includes the type of stream being supplied to the
* method. These additional parameters are for the use of the driver or the DBMS and may or
* may not be used.
* Array
, Blob
,
* Clob
and Ref
are returned as SerialArray
,
* SerialBlob
, SerialClob
and SerialRef
* respectively.
*
* @return an array of Object
instances that includes the
* parameter values that may be set in this RowSet
object's
* command; an empty array if no parameters have been set
* @throws SQLException if an error occurs retrieveing the object array of
* parameters of this RowSet
object or if not all parameters have
* been set
*/
public Object[] getParams() throws SQLException {
if (params == null) {
initParams();
Object [] paramsArray = new Object[params.size()];
return paramsArray;
} else {
// The parameters may be set in random order
// but all must be set, check to verify all
// have been set till the last parameter
// else throw exception.
Object[] paramsArray = new Object[params.size()];
for (int i = 0; i < params.size(); i++) {
paramsArray[i] = params.get(Integer.valueOf(i));
if (paramsArray[i] == null) {
throw new SQLException("missing parameter: " + (i + 1));
} //end if
} //end for
return paramsArray;
} //end if
} //end getParams
/**
* Sets the designated parameter to SQL NULL
.
*
* java.sql.Types
* @exception SQLException if a database access error occurs or
* this method is called on a closed CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @since 1.4
*/
public void setNull(String parameterName, int sqlType) throws SQLException {
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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.
*
* java.sql.Types
* @param typeName the fully-qualified name of an SQL user-defined type;
* ignored if the parameter is not a user-defined type or
* SQL REF
value
* @exception SQLException if a database access error occurs or
* this method is called on a closed CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @since 1.4
*/
public void setNull (String parameterName, int sqlType, String typeName)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given Java boolean
value.
* The driver converts this
* to an SQL BIT
or BOOLEAN
value when it sends it to the database.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @exception SQLException if a database access error occurs or
* this method is called on a closed CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setBoolean(String parameterName, boolean x) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given Java byte
value.
* The driver converts this
* to an SQL TINYINT
value when it sends it to the database.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @exception SQLException if a database access error occurs or
* this method is called on a closed CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setByte(String parameterName, byte x) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given Java short
value.
* The driver converts this
* to an SQL SMALLINT
value when it sends it to the database.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @exception SQLException if a database access error occurs or
* this method is called on a closed CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setShort(String parameterName, short x) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given Java int
value.
* The driver converts this
* to an SQL INTEGER
value when it sends it to the database.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @exception SQLException if a database access error occurs or
* this method is called on a closed CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setInt(String parameterName, int x) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given Java long
value.
* The driver converts this
* to an SQL BIGINT
value when it sends it to the database.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @exception SQLException if a database access error occurs or
* this method is called on a closed CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setLong(String parameterName, long x) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given Java float
value.
* The driver converts this
* to an SQL FLOAT
value when it sends it to the database.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @exception SQLException if a database access error occurs or
* this method is called on a closed CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setFloat(String parameterName, float x) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given Java double
value.
* The driver converts this
* to an SQL DOUBLE
value when it sends it to the database.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @exception SQLException if a database access error occurs or
* this method is called on a closed CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setDouble(String parameterName, double x) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given
* java.math.BigDecimal
value.
* The driver converts this to an SQL NUMERIC
value when
* it sends it to the database.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @exception SQLException if a database access error occurs or
* this method is called on a closed CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given 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.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @exception SQLException if a database access error occurs or
* this method is called on a closed CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setString(String parameterName, String x) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given 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.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @exception SQLException if a database access error occurs or
* this method is called on a closed CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setBytes(String parameterName, byte x[]) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given java.sql.Timestamp
value.
* The driver
* converts this to an SQL TIMESTAMP
value when it sends it to the
* database.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @exception SQLException if a database access error occurs or
* this method is called on a closed CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setTimestamp(String parameterName, java.sql.Timestamp x)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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.
*
* CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @since 1.4
*/
public void setAsciiStream(String parameterName, java.io.InputStream x, int length)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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.
*
* CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @since 1.4
*/
public void setBinaryStream(String parameterName, java.io.InputStream x,
int length) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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.
*
* java.io.Reader
object that
* contains the UNICODE data used as the designated parameter
* @param length the number of characters in the stream
* @exception SQLException if a database access error occurs or
* this method is called on a closed CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @since 1.4
*/
public void setCharacterStream(String parameterName,
java.io.Reader reader,
int length) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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.
*
* setAsciiStream
which takes a length parameter.
*
* @param parameterName the name of the parameter
* @param x the Java input stream that contains the ASCII parameter value
* @exception SQLException if a database access error occurs or
* this method is called on a closed CallableStatement
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
* @since 1.6
*/
public void setAsciiStream(String parameterName, java.io.InputStream x)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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.
*
* setBinaryStream
which takes a length parameter.
*
* @param parameterName the name of the parameter
* @param x the java input stream which contains the binary parameter value
* @exception SQLException if a database access error occurs or
* this method is called on a closed CallableStatement
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
* @since 1.6
*/
public void setBinaryStream(String parameterName, java.io.InputStream x)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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.
*
* setCharacterStream
which takes a length parameter.
*
* @param parameterName the name of the parameter
* @param reader the java.io.Reader
object that contains the
* Unicode data
* @exception SQLException if a database access error occurs or
* this method is called on a closed CallableStatement
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
* @since 1.6
*/
public void setCharacterStream(String parameterName,
java.io.Reader reader) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter in this RowSet
object's command
* 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.
* setNCharacterStream
which takes a length parameter.
*
* @param parameterIndex of the first parameter is 1, the second is 2, ...
* @param value the parameter value
* @throws SQLException 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
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
* @since 1.6
*/
public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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.
*
* 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
, NClob
,
* Struct
, java.net.URL
,
* or Array
, the driver should pass it to the database as a
* value of the corresponding SQL type.
* CallableStatement
* @exception SQLFeatureNotSupportedException if targetSqlType
is
* a ARRAY
, BLOB
, CLOB
,
* DATALINK
, JAVA_OBJECT
, NCHAR
,
* NCLOB
, NVARCHAR
, LONGNVARCHAR
,
* REF
, ROWID
, SQLXML
* or STRUCT
data type and the JDBC driver does not support
* this data type
* @see Types
* @see #getParams
* @since 1.4
*/
public void setObject(String parameterName, Object x, int targetSqlType, int scale)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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.
*
* @param parameterName the name of the parameter
* @param x the object containing the input parameter value
* @param targetSqlType the SQL type (as defined in java.sql.Types) to be
* sent to the database
* @exception SQLException if a database access error occurs or
* this method is called on a closed CallableStatement
* @exception SQLFeatureNotSupportedException if targetSqlType
is
* a ARRAY
, BLOB
, CLOB
,
* DATALINK
, JAVA_OBJECT
, NCHAR
,
* NCLOB
, NVARCHAR
, LONGNVARCHAR
,
* REF
, ROWID
, SQLXML
* or STRUCT
data type and the JDBC driver does not support
* this data type
* @see #getParams
* @since 1.4
*/
public void setObject(String parameterName, Object x, int targetSqlType)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the value of the designated parameter with the given object.
* The second parameter must be of type Object
; therefore, the
* java.lang
equivalent objects should be used for built-in types.
*
* Object
types to SQL types. The given argument
* will be converted to the corresponding SQL type before being
* sent to the database.
*
* 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
, NClob
,
* Struct
, java.net.URL
,
* or Array
, the driver should pass it to the database as a
* value of the corresponding SQL type.
* CallableStatement
or if the given
* Object
parameter is ambiguous
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setObject(String parameterName, Object x) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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
* @param parameterIndex index of the first parameter is 1,
* the second is 2, ...
* @param inputStream An object that contains the data to set the parameter
* value to.
* @param length the number of bytes in the parameter data.
* @throws SQLException if a database access error occurs,
* this method is called on a closed PreparedStatement
,
* if parameterIndex does not correspond
* to a parameter marker in the SQL statement, if the length specified
* is less than zero or if the number of bytes in the inputstream does not match
* the specfied length.
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
*
* @since 1.6
*/
public void setBlob(int parameterIndex, InputStream inputStream, long length)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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
*
* setBlob
which takes a length parameter.
*
* @param parameterIndex index of the first parameter is 1,
* the second is 2, ...
* @param inputStream An object that contains the data to set the parameter
* value to.
* @throws SQLException 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,
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
*
* @since 1.6
*/
public void setBlob(int parameterIndex, InputStream inputStream)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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 CallableStatement
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
*
* @param parameterName the name of the parameter to be set
* the second is 2, ...
*
* @param inputStream An object that contains the data to set the parameter
* value to.
* @param length the number of bytes in the parameter data.
* @throws SQLException if parameterIndex does not correspond
* to a parameter marker in the SQL statement, or if the length specified
* is less than zero; if the number of bytes in the inputstream does not match
* the specfied length; if a database access error occurs or
* this method is called on a closed CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
*
* @since 1.6
*/
public void setBlob(String parameterName, InputStream inputStream, long length)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given java.sql.Blob
object.
* The driver converts this to an SQL BLOB
value when it
* sends it to the database.
*
* @param parameterName the name of the parameter
* @param x a Blob
object that maps an SQL BLOB
value
* @exception SQLException if a database access error occurs or
* this method is called on a closed CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @since 1.6
*/
public void setBlob (String parameterName, Blob x) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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 send to the server as a LONGVARBINARY
or a BLOB
*
* setBlob
which takes a length parameter.
*
* @param parameterName the name of the parameter
* @param inputStream An object that contains the data to set the parameter
* value to.
* @throws SQLException if a database access error occurs or
* this method is called on a closed CallableStatement
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
*
* @since 1.6
*/
public void setBlob(String parameterName, InputStream inputStream)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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
* @param parameterIndex index of the first parameter is 1, the second is 2, ...
* @param reader An object that contains the data to set the parameter value to.
* @param length the number of characters in the parameter data.
* @throws SQLException if a database access error occurs, this method is called on
* a closed PreparedStatement
, if parameterIndex does not correspond to a parameter
* marker in the SQL statement, or if the length specified is less than zero.
*
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
* @since 1.6
*/
public void setClob(int parameterIndex, Reader reader, long length)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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
*
* setClob
which takes a length parameter.
*
* @param parameterIndex index of the first parameter is 1, the second is 2, ...
* @param reader An object that contains the data to set the parameter value to.
* @throws SQLException 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
*
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
* @since 1.6
*/
public void setClob(int parameterIndex, Reader reader)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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 CallableStatement
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 send to the server as a LONGVARCHAR
or a CLOB
* @param parameterName the name of the parameter to be set
* @param reader An object that contains the data to set the parameter value to.
* @param length the number of characters in the parameter data.
* @throws SQLException if parameterIndex does not correspond to a parameter
* marker in the SQL statement; if the length specified is less than zero;
* a database access error occurs or
* this method is called on a closed CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
*
* @since 1.6
*/
public void setClob(String parameterName, Reader reader, long length)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given java.sql.Clob
object.
* The driver converts this to an SQL CLOB
value when it
* sends it to the database.
*
* @param parameterName the name of the parameter
* @param x a Clob
object that maps an SQL CLOB
value
* @exception SQLException if a database access error occurs or
* this method is called on a closed CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @since 1.6
*/
public void setClob (String parameterName, Clob x) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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 send to the server as a LONGVARCHAR
or a CLOB
*
* setClob
which takes a length parameter.
*
* @param parameterName the name of the parameter
* @param reader An object that contains the data to set the parameter value to.
* @throws SQLException if a database access error occurs or this method is called on
* a closed CallableStatement
*
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
* @since 1.6
*/
public void setClob(String parameterName, Reader reader)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given java.sql.Date
value
* using the default time zone of the virtual machine that is running
* the application.
* The driver converts this
* to an SQL DATE
value when it sends it to the database.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @exception SQLException if a database access error occurs or
* this method is called on a closed CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setDate(String parameterName, java.sql.Date x)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @param cal the Calendar
object the driver will use
* to construct the date
* @exception SQLException if a database access error occurs or
* this method is called on a closed CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setDate(String parameterName, java.sql.Date x, Calendar cal)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given java.sql.Time
value.
* The driver converts this
* to an SQL TIME
value when it sends it to the database.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @exception SQLException if a database access error occurs or
* this method is called on a closed CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setTime(String parameterName, java.sql.Time x)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @param cal the Calendar
object the driver will use
* to construct the time
* @exception SQLException if a database access error occurs or
* this method is called on a closed CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setTime(String parameterName, java.sql.Time x, Calendar cal)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @param cal the Calendar
object the driver will use
* to construct the timestamp
* @exception SQLException if a database access error occurs or
* this method is called on a closed CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setTimestamp(String parameterName, java.sql.Timestamp x, Calendar cal)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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.
* @param parameterIndex index of the first parameter is 1, the second is 2, ...
* @param xmlObject a SQLXML
object that maps an SQL XML
value
* @throws SQLException if a database access error occurs, this method
* is called on a closed result set,
* the java.xml.transform.Result
,
* Writer
or OutputStream
has not been closed
* for the SQLXML
object or
* if there is an error processing the XML value. The getCause
method
* of the exception may provide a more detailed exception, for example, if the
* stream does not contain valid XML.
* @since 1.6
*/
public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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.
* @param parameterName the name of the parameter
* @param xmlObject a SQLXML
object that maps an SQL XML
value
* @throws SQLException if a database access error occurs, this method
* is called on a closed result set,
* the java.xml.transform.Result
,
* Writer
or OutputStream
has not been closed
* for the SQLXML
object or
* if there is an error processing the XML value. The getCause
method
* of the exception may provide a more detailed exception, for example, if the
* stream does not contain valid XML.
* @since 1.6
*/
public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the parameter value
* @throws SQLException if a database access error occurs
*
* @since 1.6
*/
public void setRowId(int parameterIndex, RowId x) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given java.sql.RowId
object. The
* driver converts this to a SQL ROWID
when it sends it to the
* database.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @throws SQLException if a database access error occurs
* @since 1.6
*/
public void setRowId(String parameterName, RowId x) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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.
*
* @param parameterIndex of the first parameter is 1, the second is 2, ...
* @param value the parameter value
* @throws SQLException if the driver does not support national
* character sets; if the driver can detect that a data conversion
* error could occur ; or if a database access error occurs
* @since 1.6
*/
public void setNString(int parameterIndex, String value) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated paramter to the given String
object.
* The driver converts this to a SQL NCHAR
or
* NVARCHAR
or LONGNVARCHAR
* @param parameterName the name of the column to be set
* @param value the parameter value
* @throws SQLException if the driver does not support national
* character sets; if the driver can detect that a data conversion
* error could occur; or if a database access error occurs
* @since 1.6
*/
public void setNString(String parameterName, String value)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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.
* @param parameterIndex of the first parameter is 1, the second is 2, ...
* @param value the parameter value
* @param length the number of characters in the parameter data.
* @throws SQLException if the driver does not support national
* character sets; if the driver can detect that a data conversion
* error could occur ; or if a database access error occurs
* @since 1.6
*/
public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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.
* @param parameterName the name of the column to be set
* @param value the parameter value
* @param length the number of characters in the parameter data.
* @throws SQLException if the driver does not support national
* character sets; if the driver can detect that a data conversion
* error could occur; or if a database access error occurs
* @since 1.6
*/
public void setNCharacterStream(String parameterName, Reader value, long length)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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.
* setNCharacterStream
which takes a length parameter.
*
* @param parameterName the name of the parameter
* @param value the parameter value
* @throws SQLException 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 CallableStatement
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
* @since 1.6
*/
public void setNCharacterStream(String parameterName, Reader value) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to a java.sql.NClob
object. The object
* implements the java.sql.NClob
interface. This NClob
* object maps to a SQL NCLOB
.
* @param parameterName the name of the column to be set
* @param value the parameter value
* @throws SQLException if the driver does not support national
* character sets; if the driver can detect that a data conversion
* error could occur; or if a database access error occurs
* @since 1.6
*/
public void setNClob(String parameterName, NClob value) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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 CallableStatement
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 send to the server as a LONGNVARCHAR
or a NCLOB
*
* @param parameterName the name of the parameter to be set
* @param reader An object that contains the data to set the parameter value to.
* @param length the number of characters in the parameter data.
* @throws 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 CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @since 1.6
*/
public void setNClob(String parameterName, Reader reader, long length)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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 send to the server as a LONGNVARCHAR
or a NCLOB
* setNClob
which takes a length parameter.
*
* @param parameterName the name of the parameter
* @param reader An object that contains the data to set the parameter value to.
* @throws SQLException 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 CallableStatement
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
*
* @since 1.6
*/
public void setNClob(String parameterName, Reader reader)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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
* @param parameterIndex index of the first parameter is 1, the second is 2, ...
* @param reader An object that contains the data to set the parameter value to.
* @param length the number of characters in the parameter data.
* @throws 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
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
*
* @since 1.6
*/
public void setNClob(int parameterIndex, Reader reader, long length)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to a java.sql.NClob
object. The driver converts this oa
* SQL NCLOB
value when it sends it to the database.
* @param parameterIndex of the first parameter is 1, the second is 2, ...
* @param value the parameter value
* @throws SQLException if the driver does not support national
* character sets; if the driver can detect that a data conversion
* error could occur ; or if a database access error occurs
* @since 1.6
*/
public void setNClob(int parameterIndex, NClob value) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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
* setNClob
which takes a length parameter.
*
* @param parameterIndex index of the first parameter is 1, the second is 2, ...
* @param reader An object that contains the data to set the parameter value to.
* @throws 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
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
*
* @since 1.6
*/
public void setNClob(int parameterIndex, Reader reader)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* 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.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the java.net.URL
object to be set
* @exception SQLException if a database access error occurs or
* this method is called on a closed PreparedStatement
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
* @since 1.4
*/
public void setURL(int parameterIndex, java.net.URL x) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
static final long serialVersionUID = 4886719666485113312L;
} //end class