diff -r 4ebc2e2fb97c -r 71c04702a3d5 src/java.sql.rowset/share/classes/javax/sql/rowset/BaseRowSet.java
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/java.sql.rowset/share/classes/javax/sql/rowset/BaseRowSet.java Tue Sep 12 19:03:39 2017 +0200
@@ -0,0 +1,4445 @@
+/*
+ * Copyright (c) 2003, 2016, 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 JavaBeans™ 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
+ * Interface™ (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
™
+ * 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.
+ *
{@code + * 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. + *
{@code + * 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:
+ * {@code + * "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 driver 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.
+*
+* @since 1.5
+*/
+
+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 connection.
+ * 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 = true;
+
+ /**
+ * 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
+ * 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
+ * An application can call the method
+ * 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:
+ * 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:
+ * 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 database-
+ * 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 database-
+ * 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.
+ * RowSetListener
+ * 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 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.
+ *
+ * @param concurrency one of the following constants:
+ * 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.TRANSACTION_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.
+ *
+ * @param rows the number of rows to fetch; 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.
+ *
+ * @return the concurrency type for this 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.
+ *
+ * @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 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), Float.valueOf(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.
+ *
+ * @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), Double.valueOf(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.
+ *
+ * @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 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
+ */
+ @Deprecated
+ 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
+ * 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, 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 retrieving 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
+ */
+ 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
+ */
+ 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
+ */
+ 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
+ */
+ 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
+ */
+ 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
+ */
+ 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
+ */
+ 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
+ */
+ 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
+ */
+ 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
+ */
+ 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
+ */
+ 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
+ */
+ 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
+ */
+ 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
+ */
+ 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
+ */
+ 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
+ */
+ 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
+ */
+ 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
+ */
+ 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
+ */
+ 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 specified 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 specified 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
+ */
+ 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
+ */
+ 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
+ */
+ 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
+ */
+ 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
+ */
+ 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.
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not
+ * support this method
+ * @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.
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not
+ * support this method
+ * @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
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not
+ * support this method
+ *
+ * @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
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not
+ * support this method
+ * @since 1.6
+ */
+ public void setRowId(String parameterName, RowId x) throws SQLException {
+ throw new SQLFeatureNotSupportedException("Feature not supported");
+ }
+
+ /**
+ * Sets the designated parameter 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
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not
+ * support this method
+ * @since 1.6
+ */
+ public void setNString(int parameterIndex, String value) throws SQLException {
+ throw new SQLFeatureNotSupportedException("Feature not supported");
+ }
+
+ /**
+ * Sets the designated parameter 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
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not
+ * support this method
+ * @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
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not
+ * support this method
+ * @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
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not
+ * support this method
+ * @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
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not
+ * support this method
+ * @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
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not
+ * support this method
+ * @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
+ */
+ public void setURL(int parameterIndex, java.net.URL x) throws SQLException {
+ throw new SQLFeatureNotSupportedException("Feature not supported");
+ }
+
+ static final long serialVersionUID = 4886719666485113312L;
+
+} //end class