|
|
Java example source code file (BaseRowSet.java)
This example Java source code file (BaseRowSet.java) is included in the alvinalexander.com
"Java Source Code
Warehouse" project. The intent of this project is to help you "Learn
Java by Example" TM.
Learn more about this Java project at its project page.
The BaseRowSet.java Java example source code
/*
* Copyright (c) 2003, 2013, 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 <code>RowSet object with its basic functionality.
* The basic functions include having properties and sending event notifications,
* which all JavaBeans™ components must implement.
*
* <h3>1.0 Overview
* The <code>BaseRowSet class provides the core functionality
* for all <code>RowSet implementations,
* and all standard implementations <b>may use this class in combination with
* one or more <code>RowSet interfaces in order to provide a standard
* vendor-specific implementation. To clarify, all implementations must implement
* at least one of the <code>RowSet interfaces (JdbcRowSet,
* <code>CachedRowSet, JoinRowSet, FilteredRowSet,
* or <code>WebRowSet). This means that any implementation that extends
* the <code>BaseRowSet class must also implement one of the RowSet
* interfaces.
* <p>
* The <code>BaseRowSet class provides the following:
*
* <UL>
* <LI>Properties
* <ul>
* <li>Fields for storing current properties
* <li>Methods for getting and setting properties
* </ul>
*
* <LI>Event notification
*
* <LI>A complete set of setter methods for setting the parameters in a
* <code>RowSet object's command
*
* <LI> Streams
* <ul>
* <li>Fields for storing stream instances
* <li>Constants for indicating the type of a stream
* </ul>
* <p>
* </UL>
*
* <h3>2.0 Setting Properties
* All rowsets maintain a set of properties, which will usually be set using
* a tool. The number and kinds of properties a rowset has will vary,
* depending on what the <code>RowSet implementation does and how it gets
* its data. For example,
* rowsets that get their data from a <code>ResultSet object need to
* set the properties that are required for making a database connection.
* If a <code>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 <code>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.
* <P>
* NOTE: In order to use a <code>DataSource object for making a
* connection, the <code>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.
*
* <h3>3.0 Setting the Command and Its Parameters
* When a rowset gets its data from a relational database, it executes a command (a query)
* that produces a <code>ResultSet object. This query is the command that is set
* for the <code>RowSet object's command property. The rowset populates itself with data by reading the
* data from the <code>ResultSet object into itself. If the query
* contains placeholders for values to be set, the <code>BaseRowSet setter methods
* are used to set these values. All setter methods allow these values to be set
* to <code>null if required.
* <P>
* The following code fragment illustrates how the
* <code>CachedRowSet™
* object <code>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.
* <PRE>{@code
* crs.setCommand("SELECT FIRST_NAME, LAST_NAME, ADDRESS FROM CUSTOMERS" +
* "WHERE CREDIT_LIMIT > ? AND REGION = ?");
* }</PRE>
* <P>
* In this example, the values for <code>CREDIT_LIMIT and
* <code>REGION are placeholder parameters, which are indicated with a
* question mark (?). The first question mark is placeholder parameter number
* <code>1, the second question mark is placeholder parameter number
* <code>2, and so on. Any placeholder parameters must be set with
* values before the query can be executed. To set these
* placeholder parameters, the <code>BaseRowSet class provides a set of setter
* methods, similar to those provided by the <code>PreparedStatement
* interface, for setting values of each data type. A <code>RowSet object stores the
* parameter values internally, and its <code>execute method uses them internally
* to set values for the placeholder parameters
* before it sends the command to the DBMS to be executed.
* <P>
* The following code fragment demonstrates
* setting the two parameters in the query from the previous example.
* <PRE>{@code
* crs.setInt(1, 5000);
* crs.setString(2, "West");
* }</PRE>
* If the <code>execute method is called at this point, the query
* sent to the DBMS will be:
* <PRE>{@code
* "SELECT FIRST_NAME, LAST_NAME, ADDRESS FROM CUSTOMERS" +
* "WHERE CREDIT_LIMIT > 5000 AND REGION = 'West'"
* }</PRE>
* NOTE: Setting <code>Array, Clob, Blob and
* <code>Ref objects as a command parameter, stores these values as
* <code>SerialArray, SerialClob, SerialBlob
* and <code>SerialRef objects respectively.
*
* <h3>4.0 Handling of Parameters Behind the Scenes
*
* NOTE: The <code>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.
* <P>
* The placeholder parameters set with the <code>BaseRowSet setter methods
* are stored as objects in an internal <code>Hashtable object.
* Primitives are stored as their <code>Object type. For example, byte
* is stored as <code>Byte object, and int is stored as
* an <code>Integer object.
* When the method <code>execute is called, the values in the
* <code>Hashtable object are substituted for the appropriate placeholder
* parameters in the command.
* <P>
* A call to the method <code>getParams returns the values stored in the
* <code>Hashtable object as an array of Object instances.
* An element in this array may be a simple <code>Object instance or an
* array (which is a type of <code>Object). The particular setter method used
* determines whether an element in this array is an <code>Object or an array.
* <P>
* 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 <code>setInt,
* <code>setString, setBoolean, and setLong fall into
* this category. After these methods have been called, a call to the method
* <code>getParams will return an array with the values that have been set. Each
* element in the array is an <code>Object instance representing the
* values that have been set. The order of these values in the array is determined by the
* <code>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 <code>RowSet object's
* command. The second element is the value to
* be set for the second placeholder parameter, and so on.
* <P>
* Several setter methods send the driver and DBMS information beyond the value to be set.
* When the method <code>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 <code>setNull is a special case
* because one version takes only
* two parameters (<code>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 <code>null, and the
* second element is the <code>int supplied for sqlType, which
* indicates the type of SQL value that is being set to <code>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 <code>null
* is a user-defined type. It takes three parameters
* (<code>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
* <code>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 <code>getParams. So, for example, if the parameter
* supplied to <code>setNull is 2, the second element in the array
* returned by <code>getParams will be an array of two or three elements.
* <P>
* Some methods, such as <code>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 <code>setDate,
* <code>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 <code>Calendar object to construct the Date,
* <code>Time, or Timestamp object being set. As is true with other
* methods that provide additional information, the element in the array returned
* by <code>getParams is an array instead of a simple Object instance.
* <P>
* The methods <code>setAsciiStream, setBinaryStream,
* <code>setCharacterStream, and setUnicodeStream (which is
* deprecated, so applications should use <code>getCharacterStream instead)
* take three parameters, so for them, the element in the array returned by
* <code>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 <code>BaseRowSet constants indicating the type of stream being set.
* <p>
* NOTE: The method <code>getParams is called internally by
* <code>RowSet implementations extending this class; it is not normally called by an
* application programmer directly.
*
* <h3>5.0 Event Notification
* The <code>BaseRowSet class provides the event notification
* mechanism for rowsets. It contains the field
* <code>listeners, methods for adding and removing listeners, and
* methods for notifying listeners of changes.
* <P>
* A listener is an object that has implemented the <code>RowSetListener interface.
* If it has been added to a <code>RowSet object's list of listeners, it will be notified
* when an event occurs on that <code>RowSet object. Each listener's
* implementation of the <code>RowSetListener methods defines what that object
* will do when it is notified that an event has occurred.
* <P>
* There are three possible events for a <code>RowSet object:
* <OL>
* <LI>the cursor moves
* <LI>an individual row is changed (updated, deleted, or inserted)
* <LI>the contents of the entire RowSet object are changed
* </OL>
* <P>
* The <code>BaseRowSet method used for the notification indicates the
* type of event that has occurred. For example, the method
* <code>notifyRowChanged indicates that a row has been updated,
* deleted, or inserted. Each of the notification methods creates a
* <code>RowSetEvent object, which is supplied to the listener in order to
* identify the <code>RowSet object on which the event occurred.
* What the listener does with this information, which may be nothing, depends on how it was
* implemented.
*
* <h3>6.0 Default Behavior
* A default <code>BaseRowSet object is initialized with many starting values.
*
* The following is true of a default <code>RowSet instance that extends
* the <code>BaseRowSet class:
* <UL>
* <LI>Has a scrollable cursor and does not show changes
* made by others.
* <LI>Is updatable.
* <LI>Does not show rows that have been deleted.
* <LI>Has no time limit for how long a driver may take to
* execute the <code>RowSet object's command.
* <LI>Has no limit for the number of rows it may contain.
* <LI>Has no limit for the number of bytes a column may contain. NOTE: This
* limit applies only to columns that hold values of the
* following types: <code>BINARY, VARBINARY,
* <code>LONGVARBINARY, CHAR, VARCHAR,
* and <code>LONGVARCHAR.
* <LI>Will not see uncommitted data (make "dirty" reads).
* <LI>Has escape processing turned on.
* <LI>Has its connection's type map set to null.
* <LI>Has an empty Vector object for storing the values set
* for the placeholder parameters in the <code>RowSet object's command.
* </UL>
* <p>
* 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 <code>CachedRowSet object crs to 500.
* <PRE>
* crs.setMaxRows(500);
* </PRE>
* Methods implemented in extensions of this <code>BaseRowSet class must throw an
* <code>SQLException object for any violation of the defined assertions. Also, if the
* extending class overrides and reimplements any <code>BaseRowSet method and encounters
* connectivity or underlying data source issues, that method <b>may in addition throw an
* <code>SQLException object for that reason.
*/
public abstract class BaseRowSet implements Serializable, Cloneable {
/**
* A constant indicating to a <code>RowSetReaderImpl object
* that a given parameter is a Unicode stream. This
* <code>RowSetReaderImpl object is provided as an extension of the
* <code>SyncProvider abstract class defined in the
* <code>SyncFactory static factory SPI mechanism.
*/
public static final int UNICODE_STREAM_PARAM = 0;
/**
* A constant indicating to a <code>RowSetReaderImpl object
* that a given parameter is a binary stream. A
* <code>RowSetReaderImpl object is provided as an extension of the
* <code>SyncProvider abstract class defined in the
* <code>SyncFactory static factory SPI mechanism.
*/
public static final int BINARY_STREAM_PARAM = 1;
/**
* A constant indicating to a <code>RowSetReaderImpl object
* that a given parameter is an ASCII stream. A
* <code>RowSetReaderImpl object is provided as an extension of the
* <code>SyncProvider abstract class defined in the
* <code>SyncFactory static factory SPI mechanism.
*/
public static final int ASCII_STREAM_PARAM = 2;
/**
* The <code>InputStream object that will be
* returned by the method <code>getBinaryStream, which is
* specified in the <code>ResultSet interface.
* @serial
*/
protected java.io.InputStream binaryStream;
/**
* The <code>InputStream object that will be
* returned by the method <code>getUnicodeStream,
* which is specified in the <code>ResultSet interface.
* @serial
*/
protected java.io.InputStream unicodeStream;
/**
* The <code>InputStream object that will be
* returned by the method <code>getAsciiStream,
* which is specified in the <code>ResultSet interface.
* @serial
*/
protected java.io.InputStream asciiStream;
/**
* The <code>Reader object that will be
* returned by the method <code>getCharacterStream,
* which is specified in the <code>ResultSet interface.
* @serial
*/
protected java.io.Reader charStream;
/**
* The query that will be sent to the DBMS for execution when the
* method <code>execute is called.
* @serial
*/
private String command;
/**
* The JDBC URL the reader, writer, or both supply to the method
* <code>DriverManager.getConnection when the
* <code>DriverManager is used to get a connection.
* <P>
* The JDBC URL identifies the driver to be used to make the conndection.
* This URL can be found in the documentation supplied by the driver
* vendor.
* @serial
*/
private String URL;
/**
* The logical name of the data source that the reader/writer should use
* in order to retrieve a <code>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
* <code>DriverManager.getConnection when the
* <code>DriverManager is used to get a connection.
* @serial
*/
private transient String username;
/**
* The password the reader, writer, or both supply to the method
* <code>DriverManager.getConnection when the
* <code>DriverManager is used to get a connection.
* @serial
*/
private transient String password;
/**
* A constant indicating the type of this JDBC <code>RowSet
* object. It must be one of the following <code>ResultSet
* constants: <code>TYPE_FORWARD_ONLY,
* <code>TYPE_SCROLL_INSENSITIVE, or
* <code>TYPE_SCROLL_SENSITIVE.
* @serial
*/
private int rowSetType = ResultSet.TYPE_SCROLL_INSENSITIVE;
/**
* A <code>boolean indicating whether deleted rows are visible in this
* JDBC <code>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 <code>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 <code>RowSet
* object. It must be one of the following <code>ResultSet
* constants: <code>CONCUR_READ_ONLY or
* <code>CONCUR_UPDATABLE.
* @serial
*/
private int concurrency = ResultSet.CONCUR_UPDATABLE;
/**
* A <code>boolean indicating whether this JDBC RowSet
* object is read-only. <code>true indicates that it is read-only;
* <code>false that it is writable.
* @serial
*/
private boolean readOnly;
/**
* A <code>boolean indicating whether the reader for this
* JDBC <code>RowSet object should perform escape processing.
* <code>true means that escape processing is turned on;
* <code>false that it is not. The default is true.
* @serial
*/
private boolean escapeProcessing;
/**
* A constant indicating the isolation level of the connection
* for this JDBC <code>RowSet object . It must be one of
* the following <code>Connection constants:
* <code>TRANSACTION_NONE,
* <code>TRANSACTION_READ_UNCOMMITTED,
* <code>TRANSACTION_READ_COMMITTED,
* <code>TRANSACTION_REPEATABLE_READ or
* <code>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 <code>RowSet object is going
* to be fetched. The following <code>ResultSet constants are
* possible values:
* <code>FETCH_FORWARD,
* <code>FETCH_REVERSE,
* <code>FETCH_UNKNOWN.
* <P>
* 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 <code>RowSet object .
* <P>
* Unused at this time.
* @serial
*/
private int fetchSize = 0; // default fetchSize
/**
* The <code>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 Map<String, Class map;
/**
* A <code>Vector object that holds the list of listeners
* that have registered with this <code>RowSet object.
* @serial
*/
private Vector<RowSetListener> listeners;
/**
* A <code>Vector object that holds the parameters set
* for this <code>RowSet object's current command.
* @serial
*/
private Hashtable<Integer, Object> params; // could be transient?
/**
* Constructs a new <code>BaseRowSet object initialized with
* a default <code>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 Vector<RowSetListener>();
}
/**
* Performs the necessary internal configurations and initializations
* to allow any JDBC <code>RowSet implementation to start using
* the standard facilities provided by a <code>BaseRowSet
* instance. This method <b>should be called after the RowSet object
* has been instantiated to correctly initialize all parameters. This method
* <b>should never be called by an application, but is called from with
* a <code>RowSet implementation extending this class.
*/
protected void initParams() {
params = new Hashtable<Integer, Object>();
}
//--------------------------------------------------------------------
// Events
//--------------------------------------------------------------------
/**
* The listener will be notified whenever an event occurs on this <code>RowSet
* object.
* <P>
* 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 <code>RowSet object.
* <p>
* <b>Note: if the RowSetListener object is
* <code>null, this method silently discards the null
* value and does not add a null reference to the set of listeners.
* <p>
* <b>Note: if the listener is already set, and the new RowSetListerner
* instance is added to the set of listeners already registered to receive
* event notifications from this <code>RowSet.
*
* @param listener an object that has implemented the
* <code>javax.sql.RowSetListener interface and wants to be notified
* of any events that occur on this <code>RowSet object; May be
* null.
* @see #removeRowSetListener
*/
public void addRowSetListener(RowSetListener listener) {
listeners.add(listener);
}
/**
* Removes the designated object from this <code>RowSet object's list of listeners.
* If the given argument is not a registered listener, this method
* does nothing.
*
* <b>Note: if the RowSetListener object is
* <code>null, this method silently discards the null
* value.
*
* @param listener a <code>RowSetListener object that is on the list
* of listeners for this <code>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
* <code>RowSet object that its cursor has moved.
* <P>
* When an application calls a method to move the cursor,
* that method moves the cursor and then calls this method
* internally. An application <b>should never invoke
* this method directly.
*
* @throws SQLException if the class extending the <code>BaseRowSet
* abstract class does not implement the <code>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 <code>RowSet object that
* one of its rows has changed.
* <P>
* When an application calls a method that changes a row, such as
* the <code>CachedRowSet methods insertRow,
* <code>updateRow, or deleteRow,
* that method calls <code>notifyRowChanged
* internally. An application <b>should never invoke
* this method directly.
*
* @throws SQLException if the class extending the <code>BaseRowSet
* abstract class does not implement the <code>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 <code>RowSet
* object that its entire contents have changed.
* <P>
* When an application calls methods that change the entire contents
* of the <code>RowSet object, such as the CachedRowSet methods
* <code>execute, populate, restoreOriginal,
* or <code>release, that method calls notifyRowSetChanged
* internally (either directly or indirectly). An application <b>should
* never invoke this method directly.
*
* @throws SQLException if the class extending the <code>BaseRowSet
* abstract class does not implement the <code>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
* <code>RowSet object. The command property contains the query that
* will be executed to populate this <code>RowSet object.
* <P>
* The SQL query returned by this method is used by <code>RowSet methods
* such as <code>execute and populate, which may be implemented
* by any class that extends the <code>BaseRowSet abstract class and
* implements one or more of the standard JSR-114 <code>RowSet
* interfaces.
* <P>
* The command is used by the <code>RowSet object's
* reader to obtain a <code>ResultSet object. The reader then
* reads the data from the <code>ResultSet object and uses it to
* to populate this <code>RowSet object.
* <P>
* The default value for the <code>command property is null.
*
* @return the <code>String that is the value for this
* <code>RowSet object's command property;
* may be <code>null
* @see #setCommand
*/
public String getCommand() {
return command;
}
/**
* Sets this <code>RowSet object's command property to
* the given <code>String object and clears the parameters, if any,
* that were set for the previous command.
* <P>
* The <code>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 <code>null.
*
* @param cmd a <code>String object containing an SQL query
* that will be set as this <code>RowSet object's command
* property; may be <code>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 <code>RowSet object's
* <code>javax.sql.Reader object uses to make a connection
* with a relational database using a JDBC technology-enabled driver.
*<P>
* The <code>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 <code>String object that contains the JDBC URL
* used to establish the connection for this <code>RowSet
* object; may be <code>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 <code>RowSet object
* to the given <code>String object and sets the dataSource name
* property to <code>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 <code>DriverManager.
* The correct JDBC URL for the specific driver to be used can be found
* in the driver documentation. Although there are guidelines for for how
* a JDBC URL is formed,
* a driver vendor can specify any <code>String object except
* one with a length of <code>0 (an empty string).
* <P>
* Setting the Url property is optional if connections are established using
* a <code>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
* <code>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 <code>String object that contains the JDBC URL
* that will be used to establish the connection to a database for this
* <code>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 <code>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 <code>javax.sql.DataSource object. This
* <code>DataSource object can be used to establish a connection
* to the data source that it represents.
* <P>
* 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 <code>String object that identifies the
* <code>DataSource object to be used for making a
* connection; if no logical name has been set, <code>null
* is returned.
* @see #setDataSourceName
*/
public String getDataSourceName() {
return dataSource;
}
/**
* Sets the <code>DataSource name property for this RowSet
* object to the given logical name and sets this <code>RowSet object's
* Url property to <code>null. The name must have been bound to a
* <code>DataSource object in a JNDI naming service so that an
* application can do a lookup using that name to retrieve the
* <code>DataSource object bound to it. The DataSource
* object can then be used to establish a connection to the data source it
* represents.
* <P>
* 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 <code>String object with the name that can be supplied
* to a naming service based on JNDI technology to retrieve the
* <code>DataSource object that can be used to get a connection;
* may be <code>null but must not be an empty string
* @throws SQLException if an empty string is provided as the <code>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 <code>execute.
*
* @return the <code>String object containing the user name that
* is supplied to the data source to create a connection; may be
* <code>null (default value) if not set
* @see #setUsername
*/
public String getUsername() {
return username;
}
/**
* Sets the username property for this <code>RowSet object
* to the given user name. Because it
* is not serialized, the username property is set at run time before
* calling the method <code>execute.
*
* @param name the <code>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
* <code>RowSet object. Because the password property is not
* serialized, it is set at run time before calling the method
* <code>execute. The default value is null
*
* @return the <code>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
* <code>RowSet object to the given String
* object. Because the password property is not
* serialized, it is set at run time before calling the method
* <code>execute.
*
* @param pass the <code>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 <code>RowSet object to the specified type.
* The default type is <code>ResultSet.TYPE_SCROLL_INSENSITIVE.
*
* @param type one of the following constants:
* <code>ResultSet.TYPE_FORWARD_ONLY,
* <code>ResultSet.TYPE_SCROLL_INSENSITIVE, or
* <code>ResultSet.TYPE_SCROLL_SENSITIVE
* @throws SQLException if the parameter supplied is not one of the
* following constants:
* <code>ResultSet.TYPE_FORWARD_ONLY or
* <code>ResultSet.TYPE_SCROLL_INSENSITIVE
* <code>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 <code>RowSet object. The type is initially
* determined by the statement that created the <code>RowSet object.
* The <code>RowSet object can call the method
* <code>setType at any time to change its
* type. The default is <code>TYPE_SCROLL_INSENSITIVE.
*
* @return the type of this JDBC <code>RowSet
* object, which must be one of the following:
* <code>ResultSet.TYPE_FORWARD_ONLY,
* <code>ResultSet.TYPE_SCROLL_INSENSITIVE, or
* <code>ResultSet.TYPE_SCROLL_SENSITIVE
* @throws SQLException if an error occurs getting the type of
* of this <code>RowSet object
* @see #setType
*/
public int getType() throws SQLException {
return rowSetType;
}
/**
* Sets the concurrency for this <code>RowSet object to
* the specified concurrency. The default concurrency for any <code>RowSet
* object (connected or disconnected) is <code>ResultSet.CONCUR_UPDATABLE,
* but this method may be called at any time to change the concurrency.
* <P>
* @param concurrency one of the following constants:
* <code>ResultSet.CONCUR_READ_ONLY or
* <code>ResultSet.CONCUR_UPDATABLE
* @throws SQLException if the parameter supplied is not one of the
* following constants:
* <code>ResultSet.CONCUR_UPDATABLE or
* <code>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 <code>boolean indicating whether this
* <code>RowSet object is read-only.
* Any attempts to update a read-only <code>RowSet object will result in an
* <code>SQLException being thrown. By default,
* rowsets are updatable if updates are possible.
*
* @return <code>true if this RowSet object
* cannot be updated; <code>false otherwise
* @see #setConcurrency
* @see #setReadOnly
*/
public boolean isReadOnly() {
return readOnly;
};
/**
* Sets this <code>RowSet object's readOnly property to the given boolean.
*
* @param value <code>true to indicate that this
* <code>RowSet object is read-only;
* <code>false to indicate that it is updatable
*/
public void setReadOnly(boolean value) {
readOnly = value;
}
/**
* Returns the transaction isolation property for this
* <code>RowSet object's connection. This property represents
* the transaction isolation level requested for use in transactions.
* <P>
* For <code>RowSet implementations such as
* the <code>CachedRowSet that operate in a disconnected environment,
* the <code>SyncProvider object
* offers complementary locking and data integrity options. The
* options described below are pertinent only to connected <code>RowSet
* objects (<code>JdbcRowSet objects).
*
* @return one of the following constants:
* <code>Connection.TRANSACTION_NONE,
* <code>Connection.TRANSACTION_READ_UNCOMMITTED,
* <code>Connection.TRANSACTION_READ_COMMITTED,
* <code>Connection.TRANSACTION_REPEATABLE_READ, or
* <code>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 <code>RowSet object to the given
* constant. The DBMS will use this transaction isolation level for
* transactions if it can.
* <p>
* For <code>RowSet implementations such as
* the <code>CachedRowSet that operate in a disconnected environment,
* the <code>SyncProvider object being used
* offers complementary locking and data integrity options. The
* options described below are pertinent only to connected <code>RowSet
* objects (<code>JdbcRowSet objects).
*
* @param level one of the following constants, listed in ascending order:
* <code>Connection.TRANSACTION_NONE,
* <code>Connection.TRANSACTION_READ_UNCOMMITTED,
* <code>Connection.TRANSACTION_READ_COMMITTED,
* <code>Connection.TRANSACTION_REPEATABLE_READ, or
* <code>Connection.TRANSACTION_SERIALIZABLE
* @throws SQLException if the given parameter is not one of the Connection
* constants
* @see javax.sql.rowset.spi.SyncFactory
* @see javax.sql.rowset.spi.SyncProvider
* @see #getTransactionIsolation
*/
public void setTransactionIsolation(int level) throws SQLException {
if ((level != Connection.TRANSACTION_NONE) &&
(level != Connection.TRANSACTION_READ_COMMITTED) &&
(level != Connection.TRANSACTION_READ_UNCOMMITTED) &&
(level != Connection.TRANSACTION_REPEATABLE_READ) &&
(level != Connection.TRANSACTION_SERIALIZABLE))
{
throw new SQLException("Invalid transaction isolation set. Must " +
"be either " +
"Connection.TRANSACTION_NONE or " +
"Connection.TRANSACTION_READ_UNCOMMITTED or " +
"Connection.TRANSACTION_READ_COMMITTED or " +
"Connection.RRANSACTION_REPEATABLE_READ or " +
"Connection.TRANSACTION_SERIALIZABLE");
}
this.isolation = level;
}
/**
* Retrieves the type map associated with the <code>Connection
* object for this <code>RowSet object.
* <P>
* Drivers that support the JDBC 3.0 API will create
* <code>Connection objects with an associated type map.
* This type map, which is initially empty, can contain one or more
* fully-qualified SQL names and <code>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.
* <p>
* 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 <code>java.util.Map object that is the type map
* for this <code>RowSet object's connection
*/
public java.util.Map<String,Class getTypeMap() {
return map;
}
/**
* Installs the given <code>java.util.Map object as the type map
* associated with the <code>Connection object for this
* <code>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 <code>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 <code>Map
* object consists of the fully qualified SQL name of a UDT and the
* <code>Class object for the SQLData implementation
* of that UDT. May be <code>null.
*/
public void setTypeMap(java.util.Map<String,Class map) {
this.map = map;
}
/**
* Retrieves the maximum number of bytes that can be used for a column
* value in this <code>RowSet object.
* This limit applies only to columns that hold values of the
* following types: <code>BINARY, VARBINARY,
* <code>LONGVARBINARY, CHAR, VARCHAR,
* and <code>LONGVARCHAR. If the limit is exceeded, the excess
* data is silently discarded.
*
* @return an <code>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 <code>RowSet object to the given number.
* This limit applies only to columns that hold values of the
* following types: <code>BINARY, VARBINARY,
* <code>LONGVARBINARY, CHAR, VARCHAR,
* and <code>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 <code>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 <code>RowSet object may contain. If
* this limit is exceeded, the excess rows are silently dropped.
*
* @return an <code>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 <code>Rowset object can contain
*/
public int getMaxRows() throws SQLException {
return maxRows;
}
/**
* Sets the maximum number of rows that this <code>RowSet object may contain to
* the given number. If this limit is exceeded, the excess rows are
* silently dropped.
*
* @param max an <code>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 <code>RowSet object
* can contain; or if <i>max is less than 0; or
* if <i>max is less than the fetchSize of the
* <code>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 <code>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.
* <P>
* Note: Since <code>PreparedStatement objects have usually been
* parsed prior to making this call, disabling escape processing for
* prepared statements will likely have no effect.
*
* @param enable <code>true to enable escape processing;
* <code>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 <code>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
* <code>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 <code>boolean indicating whether rows marked
* for deletion appear in the set of current rows.
* The default value is <code>false.
* <P>
* Note: Allowing deleted rows to remain visible complicates the behavior
* of some of the methods. However, most <code>RowSet object users
* can simply ignore this extra detail because only sophisticated
* applications will likely want to take advantage of this feature.
*
* @return <code>true if deleted rows are visible;
* <code>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 <code>showDeleted to the given
* <code>boolean value, which determines whether
* rows marked for deletion appear in the set of current rows.
*
* @param value <code>true if deleted rows should be shown;
* <code>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
* <code>RowSet object.
*
* @return <code>true if escape processing is turned on;
* <code>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 <code>RowSet object will be
* processed. The driver may ignore this hint.
* <P>
* A <code>RowSet object inherits the default properties of the
* <code>ResultSet object from which it got its data. That
* <code>ResultSet object's default fetch direction is set by
* the <code>Statement object that created it.
* <P>
* This method applies to a <code>RowSet object only while it is
* connected to a database using a JDBC driver.
* <p>
* A <code>RowSet object may use this method at any time to change
* its setting for the fetch direction.
*
* @param direction one of <code>ResultSet.FETCH_FORWARD,
* <code>ResultSet.FETCH_REVERSE, or
* <code>ResultSet.FETCH_UNKNOWN
* @throws SQLException if (1) the <code>RowSet type is
* <code>TYPE_FORWARD_ONLY and the given fetch direction is not
* <code>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 <code>RowSet object's current setting for the
* fetch direction. The default type is <code>ResultSet.FETCH_FORWARD
*
* @return one of <code>ResultSet.FETCH_FORWARD,
* <code>ResultSet.FETCH_REVERSE, or
* <code>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 <code>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 <code>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.
* <P>
* A <code>RowSet object inherits the default properties of the
* <code>ResultSet object from which it got its data. That
* <code>ResultSet object's default fetch size is set by
* the <code>Statement object that created it.
* <P>
* This method applies to a <code>RowSet object only while it is
* connected to a database using a JDBC driver.
* For connected <code>RowSet implementations such as
* <code>JdbcRowSet, this method has a direct and immediate effect
* on the underlying JDBC driver.
* <P>
* A <code>RowSet object may use this method at any time to change
* its setting for the fetch size.
* <p>
* For <code>RowSet implementations such as
* <code>CachedRowSet, which operate in a disconnected environment,
* the <code>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 <code>SyncProvider
* object employed by the disconnected <code>RowSet object.
* <P>
*
* @param rows the number of rows to fetch; <code>0 to let the
* driver decide what the best fetch size is; must not be less
* than <code>0 or more than the maximum number of rows
* allowed for this <code>RowSet object (the number returned
* by a call to the method {@link #getMaxRows})
* @throws SQLException if the specified fetch size is less than <code>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 <code>RowSet object. The default
* value is zero.
*
* @return the number of rows suggested as the fetch size when this <code>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 <code>RowSet object.
* The default is <code>CONCUR_UPDATABLE for both connected and
* disconnected <code>RowSet objects.
* <P>
* An application can call the method <code>setConcurrency at any time
* to change a <code>RowSet object's concurrency.
* <p>
* @return the concurrency type for this <code>RowSet
* object, which must be one of the following:
* <code>ResultSet.CONCUR_READ_ONLY or
* <code>ResultSet.CONCUR_UPDATABLE
* @throws SQLException if an error occurs getting the concurrency
* of this <code>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 <code>1 and
* throws an <code>SQLException object if it is.
* <P>
* This method is called by many methods internally; it is never
* called by an application directly.
*
* @param idx an <code>int indicating which parameter is to be
* checked; the first parameter is <code>1
* @throws SQLException if the parameter is less than <code>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 <code>RowSet object's command
//---------------------------------------------------------------------
/**
* Sets the designated parameter to SQL <code>NULL.
* Note that the parameter's SQL type must be specified using one of the
* type codes defined in <code>java.sql.Types. This SQL type is
* specified in the second parameter.
* <p>
* Note that the second parameter tells the DBMS the data type of the value being
* set to <code>NULL. Some DBMSs require this information, so it is required
* in order to make code more portable.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute and populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
* <P>
* NOTE: <code>JdbcRowSet does not require the populate method
* as it is undefined in this class.
* <P>
* Calls made to the method <code>getParams after this version of
* <code>setNull
* has been called will return an <code>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 <code>null.
* The second element is the value set for <i>sqlType.
* The parameter number is indicated by an element's position in the array
* returned by the method <code>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
* <code>null, the array containing it will be the second element in
* the array returned by <code>getParams.
* <P>
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* <i>parameterIndex is parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>1 or greater
* @param sqlType an <code>int that is one of the SQL type codes
* defined in the class {@link java.sql.Types}. If a non-standard
* <i>sqlType is supplied, this method will not throw a
* <code>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 <code>NULL.
*
* Although this version of the method <code>setNull is intended
* for user-defined
* and <code>REF parameters, this method may be used to set a null
* parameter for any JDBC type. The following are user-defined types:
* <code>STRUCT, DISTINCT, and JAVA_OBJECT,
* and named array types.
*
* <P>Note: To be portable, applications must give the
* SQL type code and the fully qualified SQL type name when specifying
* a <code>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 <code>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.
* <P>
* If the parameter does not have a user-defined or <code>REF type,
* the given <code>typeName parameter is ignored.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute and populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
* <P>
* NOTE: <code>JdbcRowSet does not require the populate method
* as it is undefined in this class.
* <P>
* Calls made to the method <code>getParams after this version of
* <code>setNull
* has been called will return an <code>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 <code>null.
* The second element is the value set for <i>sqlType, and the third
* element is the value set for <i>typeName.
* The parameter number is indicated by an element's position in the array
* returned by the method <code>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
* <code>null, the array containing it will be the second element in
* the array returned by <code>getParams.
* <P>
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* <i>parameterIndex is parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>1 or greater
* @param sqlType a value from <code>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 <code>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 <code>boolean in the
* Java programming language. The driver converts this to an SQL
* <code>BIT value when it sends it to the database.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute, populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
* <p>
* NOTE: <code>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 <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>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 <code>byte in the Java
* programming language. The driver converts this to an SQL
* <code>TINYINT value when it sends it to the database.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute and populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
* <p>
* NOTE: <code>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 <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>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 <code>short in the
* Java programming language. The driver converts this to an SQL
* <code>SMALLINT value when it sends it to the database.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute and populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
* <p>
* NOTE: <code>JdbcRowSet does not require the populate method
* as it is undefined in this class.
* <p>
* @param parameterIndex the ordinal number of the placeholder parameter
* in this <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>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 <code>int in the Java
* programming language. The driver converts this to an SQL
* <code>INTEGER value when it sends it to the database.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute and populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
* <P>
* NOTE: <code>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 <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>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 <code>long in the Java
* programming language. The driver converts this to an SQL
* <code>BIGINT value when it sends it to the database.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute and populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
* <P>
* NOTE: <code>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 <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>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 <code>float in the
* Java programming language. The driver converts this to an SQL
* <code>FLOAT value when it sends it to the database.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute and populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
* <P>
* NOTE: <code>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 <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>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 <code>double in the
* Java programming language. The driver converts this to an SQL
* <code>DOUBLE value when it sends it to the database.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute and populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
* <P>
* NOTE: <code>JdbcRowSet does not require the populate method
* as it is undefined in this class.
* S
* @param parameterIndex the ordinal number of the placeholder parameter
* in this <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>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
* <code>java.lang.BigDecimal value. The driver converts this to
* an SQL <code>NUMERIC value when it sends it to the database.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute and populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
* <P>
* Note: <code>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 <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>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 <code>String
* value. The driver converts this to an SQL
* <code>VARCHAR or LONGVARCHAR value
* (depending on the argument's size relative to the driver's limits
* on <code>VARCHAR values) when it sends it to the database.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute and populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
* <p>
* NOTE: <code>JdbcRowSet does not require the populate method
* as it is undefined in this class.
* <p>
* @param parameterIndex the ordinal number of the placeholder parameter
* in this <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>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
* <code>VARBINARY or LONGVARBINARY value
* (depending on the argument's size relative to the driver's limits
* on <code>VARBINARY values) when it sends it to the database.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute and populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
* <p>
* NOTE: <code>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 <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>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 <code>java.sql.Date
* value. The driver converts this to an SQL
* <code>DATE value when it sends it to the database.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute and populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
* <P>
* NOTE: <code>JdbcRowSet does not require the populate method
* as it is undefined in this class.
* <P>
* Calls made to the method <code>getParams after this version
* of <code>setDate
* has been called will return an array with the value to be set for
* placeholder parameter number <i>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
* <i>parameterIndex is parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>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 <code>java.sql.Time
* value. The driver converts this to an SQL <code>TIME value
* when it sends it to the database.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute and populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
* <P>
* NOTE: <code>JdbcRowSet does not require the populate method
* as it is undefined in this class.
* <P>
* Calls made to the method <code>getParams after this version
* of the method <code>setTime
* has been called will return an array of the parameters that have been set.
* The parameter to be set for parameter placeholder number <i>parameterIndex
* will be the <code>Time object that was set as the second parameter
* to this method.
* <P>
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* <i>parameterIndex is parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>1 or greater
* @param x a <code>java.sql.Time object, which is to be set as the value
* for placeholder parameter <i>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
* <code>java.sql.Timestamp value.
* The driver converts this to an SQL <code>TIMESTAMP value when it
* sends it to the database.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute and populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
* <P>
* NOTE: <code>JdbcRowSet does not require the populate method
* as it is undefined in this class.
* <P>
* Calls made to the method <code>getParams after this version of
* <code>setTimestamp
* has been called will return an array with the value for parameter placeholder
* number <i>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
* <i>parameterIndex is parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>1 or greater
* @param x a <code>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
* <code>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 <code>SQLException object if the number of bytes
* read and sent to the database is not equal to <i>length.
* <P>
* When a very large ASCII value is input to a <code>LONGVARCHAR
* parameter, it may be more practical to send it via a
* <code>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 <code>CHAR format.
*
* <P>Note: This stream object can be either a standard
* Java stream object or your own subclass that implements the
* standard interface.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute and populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
* <P>
* Note: <code>JdbcRowSet does not require the populate method
* as it is undefined in this class.
* <P>
* Calls made to the method <code>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 <code>java.io.InputStream object.
* The second element is the value set for <i>length.
* The third element is an internal <code>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 <code>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 <code>getParams.
* <P>
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* <i>parameterIndex is element number parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>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 <i>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 <code>RowSet object's command
* to the given input stream.
* When a very large ASCII value is input to a <code>LONGVARCHAR
* parameter, it may be more practical to send it via a
* <code>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.
*
* <P>Note: This stream object can either be a standard
* Java stream object or your own subclass that implements the
* standard interface.
* <P>Note: Consult your JDBC driver documentation to determine if
* it might be more efficient to use a version of
* <code>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 <code>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 <code>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 <code>SQLException object if the number of bytes
* read and sent to the database is not equal to <i>length.
* <P>
* When a very large binary value is input to a
* <code>LONGVARBINARY parameter, it may be more practical
* to send it via a <code>java.io.InputStream object.
* A JDBC technology-enabled driver will read the data from the
* stream as needed until it reaches end-of-file.
*
* <P>Note: This stream object can be either a standard
* Java stream object or your own subclass that implements the
* standard interface.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute and populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
*<P>
* NOTE: <code>JdbcRowSet does not require the populate method
* as it is undefined in this class.
* <P>
* Calls made to the method <code>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 <code>java.io.InputStream object.
* The second element is the value set for <i>length.
* The third element is an internal <code>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 <code>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 <code>getParams.
* <P>
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* <i>parameterIndex is element number parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>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 <i>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 <code>RowSet object's command
* to the given input stream.
* When a very large binary value is input to a <code>LONGVARBINARY
* parameter, it may be more practical to send it via a
* <code>java.io.InputStream object. The data will be read from the
* stream as needed until end-of-file is reached.
*
* <P>Note: This stream object can either be a standard
* Java stream object or your own subclass that implements the
* standard interface.
* <P>Note: Consult your JDBC driver documentation to determine if
* it might be more efficient to use a version of
* <code>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 <code>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
* <code>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 <code>SQLException if the number of bytes
* read and sent to the database is not equal to <i>length.
* <P>
* When a very large Unicode value is input to a
* <code>LONGVARCHAR parameter, it may be more practical
* to send it via a <code>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 <code>CHAR format.
* The byte format of the Unicode stream must be Java UTF-8, as
* defined in the Java Virtual Machine Specification.
*
* <P>Note: This stream object can be either a standard
* Java stream object or your own subclass that implements the
* standard interface.
* <P>
* This method is deprecated; the method <code>getCharacterStream
* should be used in its place.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Calls made to the method <code>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 <code>java.io.InputStream object.
* The second element is the value set for <i>length.
* The third element is an internal <code>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 <code>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 <code>getParams.
* <P>
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* <i>parameterIndex is element number parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>1 or greater
* @param x the <code>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 <i>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 <code>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 <code>SQLException if the number of bytes
* read and sent to the database is not equal to <i>length.
* <P>
* When a very large Unicode value is input to a
* <code>LONGVARCHAR parameter, it may be more practical
* to send it via a <code>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 <code>CHAR format.
* The byte format of the Unicode stream must be Java UTF-8, as
* defined in the Java Virtual Machine Specification.
*
* <P>Note: This stream object can be either a standard
* Java stream object or your own subclass that implements the
* standard interface.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute and populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
* <P>
* NOTE: <code>JdbcRowSet does not require the populate method
* as it is undefined in this class.
* <P>
* Calls made to the method <code>getParams after
* <code>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 <code>java.io.Reader object.
* The second element is the value set for <i>length.
* The parameter number is indicated by an element's position in the array
* returned by the method <code>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 <code>getParams.
* <P>
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* <i>parameterIndex is element number parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>1 or greater
* @param reader the <code>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 <i>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 <code>RowSet object's command
* to the given <code>Reader
* object.
* When a very large UNICODE value is input to a <code>LONGVARCHAR
* parameter, it may be more practical to send it via a
* <code>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.
*
* <P>Note: This stream object can either be a standard
* Java stream object or your own subclass that implements the
* standard interface.
* <P>Note: Consult your JDBC driver documentation to determine if
* it might be more efficient to use a version of
* <code>setCharacterStream which takes a length parameter.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param reader the <code>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 <code>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 <code>Object in the Java
* programming language. The second parameter must be an
* <code>Object type. For integral values, the
* <code>java.lang equivalent
* objects should be used. For example, use the class <code>Integer
* for an <code>int.
* <P>
* 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
* <code>SQLData), the driver should call the method
* <code>SQLData.writeSQL to write the object to the SQL
* data stream. If, on the other hand, the object is of a class
* implementing <code>Ref, Blob, Clob,
* <code>Struct, or Array,
* the driver should pass it to the database as a value of the
* corresponding SQL type.
*
* <p>Note that this method may be used to pass database-
* specific abstract data types.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute and populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
* <P>
* NOTE: <code>JdbcRowSet does not require the populate method
* as it is undefined in this class.
* <P>
* Calls made to the method <code>getParams after this version of
* <code>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 <code>Object instance, and the
* second element is the value set for <i>targetSqlType. The
* third element is the value set for <i>scale, which the driver will
* ignore if the type of the object being set is not
* <code>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 <code>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 <code>getParams.
*<P>
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* <i>parameterIndex is element number parameterIndex -1.
*
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>1 or greater
* @param x the <code>Object containing the input parameter value;
* must be an <code>Object type
* @param targetSqlType the SQL type (as defined in <code>java.sql.Types)
* to be sent to the database. The <code>scale argument may
* further qualify this type. If a non-standard <i>targetSqlType
* is supplied, this method will not throw a <code>SQLException.
* This allows implicit support for non-standard SQL types.
* @param scale for the types <code>java.sql.Types.DECIMAL and
* <code>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
* <code>Object value.
* This method is like <code>setObject(int parameterIndex, Object x, int
* targetSqlType, int scale)</code> except that it assumes a scale of zero.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute and populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
* <P>
* NOTE: <code>JdbcRowSet does not require the populate method
* as it is undefined in this class.
* <P>
* Calls made to the method <code>getParams after this version of
* <code>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 <code>Object instance.
* The second element is the value set for <i>targetSqlType.
* The parameter number is indicated by an element's position in the array
* returned by the method <code>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 <code>getParams.
* <P>
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* <i>parameterIndex is element number parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>1 or greater
* @param x the <code>Object containing the input parameter value;
* must be an <code>Object type
* @param targetSqlType the SQL type (as defined in <code>java.sql.Types)
* to be sent to the database. If a non-standard <i>targetSqlType
* is supplied, this method will not throw a <code>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 <code>Object in the Java
* programming language. The second parameter must be an
* <code>Object
* type. For integral values, the <code>java.lang equivalent
* objects should be used. For example, use the class <code>Integer
* for an <code>int.
* <P>
* The JDBC specification defines a standard mapping from
* Java <code>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
* <code>SQLData), the driver should call the method
* <code>SQLData.writeSQL to write the object to the SQL
* data stream.
* <P>
* If, on the other hand, the object is of a class
* implementing <code>Ref, Blob, Clob,
* <code>Struct, or Array,
* the driver should pass it to the database as a value of the
* corresponding SQL type.
* <P>
* This method throws an exception if there
* is an ambiguity, for example, if the object is of a class
* implementing more than one interface.
* <P>
* Note that this method may be used to pass database-specific
* abstract data types.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute and populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
* <p>
* NOTE: <code>JdbcRowSet does not require the populate method
* as it is undefined in this class.
* <P>
* After this method has been called, a call to the
* method <code>getParams
* will return an object array of the current command parameters, which will
* include the <code>Object set for placeholder parameter number
* <code>parameterIndex.
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* <i>parameterIndex is element number parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>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 <code>Ref object in
* the Java programming language. The driver converts this to an SQL
* <code>REF value when it sends it to the database. Internally, the
* <code>Ref is represented as a SerialRef to ensure
* serializability.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute and populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
* <p>
* NOTE: <code>JdbcRowSet does not require the populate method
* as it is undefined in this class.
* <p>
* After this method has been called, a call to the
* method <code>getParams
* will return an object array of the current command parameters, which will
* include the <code>Ref object set for placeholder parameter number
* <code>parameterIndex.
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* <i>parameterIndex is element number parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>1 or greater
* @param ref a <code>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 <code>Ref object is null; or
* the <code>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 <code>Blob object in
* the Java programming language. The driver converts this to an SQL
* <code>BLOB value when it sends it to the database. Internally,
* the <code>Blob is represented as a SerialBlob
* to ensure serializability.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute and populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
* NOTE: <code>JdbcRowSet does not require the populate method
* as it is undefined in this class.
* <p>
* After this method has been called, a call to the
* method <code>getParams
* will return an object array of the current command parameters, which will
* include the <code>Blob object set for placeholder parameter number
* <code>parameterIndex.
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* <i>parameterIndex is element number parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>1 or greater
* @param x a <code>Blob object representing an SQL
* <code>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 <code>Clob object in
* the Java programming language. The driver converts this to an SQL
* <code>CLOB value when it sends it to the database. Internally, the
* <code>Clob is represented as a SerialClob to ensure
* serializability.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute and populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
* <p>
* NOTE: <code>JdbcRowSet does not require the populate method
* as it is undefined in this class.
* <p>
* After this method has been called, a call to the
* method <code>getParams
* will return an object array of the current command parameters, which will
* include the <code>Clob object set for placeholder parameter number
* <code>parameterIndex.
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* <i>parameterIndex is element number parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>1 or greater
* @param x a <code>Clob object representing an SQL
* <code>CLOB value; cannot be null
* @throws SQLException if an error occurs; the parameter index is out of
* bounds or the <code>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 <code>Array object in the
* Java programming language. The driver converts this to an SQL
* <code>ARRAY value when it sends it to the database. Internally,
* the <code>Array is represented as a SerialArray
* to ensure serializability.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute and populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
* <P>
* Note: <code>JdbcRowSet does not require the populate method
* as it is undefined in this class.
* <p>
* After this method has been called, a call to the
* method <code>getParams
* will return an object array of the current command parameters, which will
* include the <code>Array object set for placeholder parameter number
* <code>parameterIndex.
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* <i>parameterIndex is element number parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>1 or greater
* @param array an <code>Array object representing an SQL
* <code>ARRAY value; cannot be null. The Array object
* passed to this method must return a non-null Object for all
* <code>getArray() method calls. A null value will cause a
* <code>SQLException to be thrown.
* @throws SQLException if an error occurs; the parameter index is out of
* bounds or the <code>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 <code>java.sql.Date
* object.
* When the DBMS does not store time zone information, the driver will use
* the given <code>Calendar object to construct the SQL DATE
* value to send to the database. With a
* <code>Calendar object, the driver can calculate the date
* taking into account a custom time zone. If no <code>Calendar
* object is specified, the driver uses the time zone of the Virtual Machine
* that is running the application.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute and populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
* <P>
* NOTE: <code>JdbcRowSet does not require the populate method
* as it is undefined in this class.
* <P>
* Calls made to the method <code>getParams after this version of
* <code>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 <code>java.sql.Date object.
* The second element is the value set for <i>cal.
* The parameter number is indicated by an element's position in the array
* returned by the method <code>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 <code>getParams.
* <P>
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* <i>parameterIndex is parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>1 or greater
* @param x a <code>java.sql.Date object representing an SQL
* <code>DATE value
* @param cal a <code>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 <code>java.sql.Time
* object. The driver converts this
* to an SQL <code>TIME value when it sends it to the database.
* <P>
* When the DBMS does not store time zone information, the driver will use
* the given <code>Calendar object to construct the SQL TIME
* value to send to the database. With a
* <code>Calendar object, the driver can calculate the date
* taking into account a custom time zone. If no <code>Calendar
* object is specified, the driver uses the time zone of the Virtual Machine
* that is running the application.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute and populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
* <P>
* NOTE: <code>JdbcRowSet does not require the populate method
* as it is undefined in this class.
* <P>
* Calls made to the method <code>getParams after this version of
* <code>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 <code>java.sql.Time object.
* The second element is the value set for <i>cal.
* The parameter number is indicated by an element's position in the array
* returned by the method <code>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 <code>getParams.
* <P>
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* <i>parameterIndex is parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>1 or greater
* @param x a <code>java.sql.Time object
* @param cal the <code>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
* <code>java.sql.Timestamp object. The driver converts this
* to an SQL <code>TIMESTAMP value when it sends it to the database.
* <P>
* When the DBMS does not store time zone information, the driver will use
* the given <code>Calendar object to construct the SQL TIMESTAMP
* value to send to the database. With a
* <code>Calendar object, the driver can calculate the timestamp
* taking into account a custom time zone. If no <code>Calendar
* object is specified, the driver uses the time zone of the Virtual Machine
* that is running the application.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this <code>RowSet
* object's command when the method <code>execute is called.
* Methods such as <code>execute and populate must be
* provided in any class that extends this class and implements one or
* more of the standard JSR-114 <code>RowSet interfaces.
* <P>
* NOTE: <code>JdbcRowSet does not require the populate method
* as it is undefined in this class.
* <P>
* Calls made to the method <code>getParams after this version of
* <code>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 <code>java.sql.Timestamp object.
* The second element is the value set for <i>cal.
* The parameter number is indicated by an element's position in the array
* returned by the method <code>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 <code>getParams.
* <P>
* Note that because the numbering of elements in an array starts at zero,
* the array element that corresponds to placeholder parameter number
* <i>parameterIndex is parameterIndex -1.
*
* @param parameterIndex the ordinal number of the placeholder parameter
* in this <code>RowSet object's command that is to be set.
* The first parameter is 1, the second is 2, and so on; must be
* <code>1 or greater
* @param x a <code>java.sql.Timestamp object
* @param cal the <code>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 <code>RowSet
* object's internal representation of the parameters to be set in
* this <code>RowSet object's command when it is executed.
* <P>
* In general, parameter values remain in force for repeated use in
* this <code>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.
* <P>
* This method is called internally by the <code>setCommand
* method to clear all of the parameters set for the previous command.
* <P>
* Furthermore, this method differs from the <code>initParams
* method in that it maintains the schema of the <code>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
* <code>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 <code>PreparedStatement object
* that is the command for a <code>RowSet implementation extending
* the <code>BaseRowSet class.
* <P>
* Each element in the array that is returned is an <code>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
* <i>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 <code>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.
* <P>
* NOTE: Stored parameter values of types <code>Array, Blob,
* <code>Clob and Ref are returned as SerialArray,
* <code>SerialBlob, SerialClob and SerialRef
* respectively.
*
* @return an array of <code>Object instances that includes the
* parameter values that may be set in this <code>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 <code>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 <code>NULL.
*
* <P>Note: You must specify the parameter's SQL type.
*
* @param parameterName the name of the parameter
* @param sqlType the SQL type code defined in <code>java.sql.Types
* @exception SQLException if a database access error occurs or
* this method is called on a closed <code>CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @since 1.4
*/
public void setNull(String parameterName, int sqlType) throws SQLException {
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to SQL <code>NULL.
* This version of the method <code>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.
*
* <P>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 <code>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 <code>REF value
* @exception SQLException if a database access error occurs or
* this method is called on a closed <code>CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @since 1.4
*/
public void setNull (String parameterName, int sqlType, String typeName)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given Java <code>boolean value.
* The driver converts this
* to an SQL <code>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 <code>CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setBoolean(String parameterName, boolean x) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given Java <code>byte value.
* The driver converts this
* to an SQL <code>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 <code>CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setByte(String parameterName, byte x) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given Java <code>short value.
* The driver converts this
* to an SQL <code>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 <code>CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setShort(String parameterName, short x) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given Java <code>int value.
* The driver converts this
* to an SQL <code>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 <code>CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setInt(String parameterName, int x) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given Java <code>long value.
* The driver converts this
* to an SQL <code>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 <code>CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setLong(String parameterName, long x) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given Java <code>float value.
* The driver converts this
* to an SQL <code>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 <code>CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setFloat(String parameterName, float x) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given Java <code>double value.
* The driver converts this
* to an SQL <code>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 <code>CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setDouble(String parameterName, double x) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given
* <code>java.math.BigDecimal value.
* The driver converts this to an SQL <code>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 <code>CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given Java <code>String value.
* The driver converts this
* to an SQL <code>VARCHAR or LONGVARCHAR value
* (depending on the argument's
* size relative to the driver's limits on <code>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 <code>CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setString(String parameterName, String x) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given Java array of bytes.
* The driver converts this to an SQL <code>VARBINARY or
* <code>LONGVARBINARY (depending on the argument's size relative
* to the driver's limits on <code>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 <code>CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setBytes(String parameterName, byte x[]) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given <code>java.sql.Timestamp value.
* The driver
* converts this to an SQL <code>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 <code>CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setTimestamp(String parameterName, java.sql.Timestamp x)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given input stream, which will have
* the specified number of bytes.
* When a very large ASCII value is input to a <code>LONGVARCHAR
* parameter, it may be more practical to send it via a
* <code>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.
*
* <P>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 <code>CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @since 1.4
*/
public void setAsciiStream(String parameterName, java.io.InputStream x, int length)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given input stream, which will have
* the specified number of bytes.
* When a very large binary value is input to a <code>LONGVARBINARY
* parameter, it may be more practical to send it via a
* <code>java.io.InputStream object. The data will be read from the stream
* as needed until end-of-file is reached.
*
* <P>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 <code>CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @since 1.4
*/
public void setBinaryStream(String parameterName, java.io.InputStream x,
int length) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given <code>Reader
* object, which is the given number of characters long.
* When a very large UNICODE value is input to a <code>LONGVARCHAR
* parameter, it may be more practical to send it via a
* <code>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.
*
* <P>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 <code>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 <code>CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @since 1.4
*/
public void setCharacterStream(String parameterName,
java.io.Reader reader,
int length) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given input stream.
* When a very large ASCII value is input to a <code>LONGVARCHAR
* parameter, it may be more practical to send it via a
* <code>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.
*
* <P>Note: This stream object can either be a standard
* Java stream object or your own subclass that implements the
* standard interface.
* <P>Note: Consult your JDBC driver documentation to determine if
* it might be more efficient to use a version of
* <code>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 <code>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 <code>LONGVARBINARY
* parameter, it may be more practical to send it via a
* <code>java.io.InputStream object. The data will be read from the
* stream as needed until end-of-file is reached.
*
* <P>Note: This stream object can either be a standard
* Java stream object or your own subclass that implements the
* standard interface.
* <P>Note: Consult your JDBC driver documentation to determine if
* it might be more efficient to use a version of
* <code>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 <code>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 <code>Reader
* object.
* When a very large UNICODE value is input to a <code>LONGVARCHAR
* parameter, it may be more practical to send it via a
* <code>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.
*
* <P>Note: This stream object can either be a standard
* Java stream object or your own subclass that implements the
* standard interface.
* <P>Note: Consult your JDBC driver documentation to determine if
* it might be more efficient to use a version of
* <code>setCharacterStream which takes a length parameter.
*
* @param parameterName the name of the parameter
* @param reader the <code>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 <code>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 <code>RowSet object's command
* to a <code>Reader object. The
* <code>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.
* <P>Note: This stream object can either be a standard
* Java stream object or your own subclass that implements the
* standard interface.
* <P>Note: Consult your JDBC driver documentation to determine if
* it might be more efficient to use a version of
* <code>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 <code>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
* <code>java.lang equivalent objects should be used.
*
* <p>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 <code>SQLData),
* the JDBC driver should call the method <code>SQLData.writeSQL to write it
* to the SQL data stream.
* If, on the other hand, the object is of a class implementing
* <code>Ref, Blob, Clob, NClob,
* <code>Struct, java.net.URL,
* or <code>Array, the driver should pass it to the database as a
* value of the corresponding SQL type.
* <P>
* Note that this method may be used to pass datatabase-
* specific abstract data types.
*
* @param parameterName the name of the parameter
* @param x the object containing the input parameter value
* @param targetSqlType the SQL type (as defined in java.sql.Types) to be
* sent to the database. The scale argument may further qualify this type.
* @param scale for java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types,
* this is the number of digits after the decimal point. For all other
* types, this value will be ignored.
* @exception SQLException if a database access error occurs or
* this method is called on a closed <code>CallableStatement
* @exception SQLFeatureNotSupportedException if <code>targetSqlType is
* a <code>ARRAY, BLOB, CLOB,
* <code>DATALINK, JAVA_OBJECT, NCHAR,
* <code>NCLOB, NVARCHAR, LONGNVARCHAR,
* <code>REF, ROWID, SQLXML
* or <code>STRUCT data type and the JDBC driver does not support
* this data type
* @see Types
* @see #getParams
* @since 1.4
*/
public void setObject(String parameterName, Object x, int targetSqlType, int scale)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the value of the designated parameter with the given object.
* This method is like the method <code>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 <code>CallableStatement
* @exception SQLFeatureNotSupportedException if <code>targetSqlType is
* a <code>ARRAY, BLOB, CLOB,
* <code>DATALINK, JAVA_OBJECT, NCHAR,
* <code>NCLOB, NVARCHAR, LONGNVARCHAR,
* <code>REF, ROWID, SQLXML
* or <code>STRUCT data type and the JDBC driver does not support
* this data type
* @see #getParams
* @since 1.4
*/
public void setObject(String parameterName, Object x, int targetSqlType)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the value of the designated parameter with the given object.
* The second parameter must be of type <code>Object; therefore, the
* <code>java.lang equivalent objects should be used for built-in types.
*
* <p>The JDBC specification specifies a standard mapping from
* Java <code>Object types to SQL types. The given argument
* will be converted to the corresponding SQL type before being
* sent to the database.
*
* <p>Note that this method may be used to pass datatabase-
* specific abstract data types, by using a driver-specific Java
* type.
*
* If the object is of a class implementing the interface <code>SQLData,
* the JDBC driver should call the method <code>SQLData.writeSQL
* to write it to the SQL data stream.
* If, on the other hand, the object is of a class implementing
* <code>Ref, Blob, Clob, NClob,
* <code>Struct, java.net.URL,
* or <code>Array, the driver should pass it to the database as a
* value of the corresponding SQL type.
* <P>
* 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 <code>CallableStatement or if the given
* <code>Object parameter is ambiguous
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setObject(String parameterName, Object x) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to a <code>InputStream object. The inputstream must contain the number
* of characters specified by length otherwise a <code>SQLException will be
* generated when the <code>PreparedStatement is executed.
* This method differs from the <code>setBinaryStream (int, InputStream, int)
* method because it informs the driver that the parameter value should be
* sent to the server as a <code>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 <code>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 <code>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 <code>InputStream object.
* This method differs from the <code>setBinaryStream (int, InputStream)
* method because it informs the driver that the parameter value should be
* sent to the server as a <code>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 <code>LONGVARBINARY or a BLOB
*
* <P>Note: Consult your JDBC driver documentation to determine if
* it might be more efficient to use a version of
* <code>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 <code>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 <code>InputStream object. The inputstream must contain the number
* of characters specified by length, otherwise a <code>SQLException will be
* generated when the <code>CallableStatement is executed.
* This method differs from the <code>setBinaryStream (int, InputStream, int)
* method because it informs the driver that the parameter value should be
* sent to the server as a <code>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 <code>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 <code>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 <code>java.sql.Blob object.
* The driver converts this to an SQL <code>BLOB value when it
* sends it to the database.
*
* @param parameterName the name of the parameter
* @param x a <code>Blob object that maps an SQL BLOB value
* @exception SQLException if a database access error occurs or
* this method is called on a closed <code>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 <code>InputStream object.
* This method differs from the <code>setBinaryStream (int, InputStream)
* method because it informs the driver that the parameter value should be
* sent to the server as a <code>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 <code>LONGVARBINARY or a BLOB
*
* <P>Note: Consult your JDBC driver documentation to determine if
* it might be more efficient to use a version of
* <code>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 <code>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 <code>Reader object. The reader must contain the number
* of characters specified by length otherwise a <code>SQLException will be
* generated when the <code>PreparedStatement is executed.
*This method differs from the <code>setCharacterStream (int, Reader, int) method
* because it informs the driver that the parameter value should be sent to
* the server as a <code>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 <code>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 <code>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 <code>Reader object.
* This method differs from the <code>setCharacterStream (int, Reader) method
* because it informs the driver that the parameter value should be sent to
* the server as a <code>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 <code>LONGVARCHAR or a CLOB
*
* <P>Note: Consult your JDBC driver documentation to determine if
* it might be more efficient to use a version of
* <code>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 <code>PreparedStatementor 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 <code>Reader object. The reader must contain the number
* of characters specified by length otherwise a <code>SQLException will be
* generated when the <code>CallableStatement is executed.
* This method differs from the <code>setCharacterStream (int, Reader, int) method
* because it informs the driver that the parameter value should be sent to
* the server as a <code>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 <code>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 <code>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 <code>java.sql.Clob object.
* The driver converts this to an SQL <code>CLOB value when it
* sends it to the database.
*
* @param parameterName the name of the parameter
* @param x a <code>Clob object that maps an SQL CLOB value
* @exception SQLException if a database access error occurs or
* this method is called on a closed <code>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 <code>Reader object.
* This method differs from the <code>setCharacterStream (int, Reader) method
* because it informs the driver that the parameter value should be sent to
* the server as a <code>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 <code>LONGVARCHAR or a CLOB
*
* <P>Note: Consult your JDBC driver documentation to determine if
* it might be more efficient to use a version of
* <code>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 <code>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 <code>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 <code>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 <code>CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setDate(String parameterName, java.sql.Date x)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given <code>java.sql.Date value,
* using the given <code>Calendar object. The driver uses
* the <code>Calendar object to construct an SQL DATE value,
* which the driver then sends to the database. With a
* a <code>Calendar object, the driver can calculate the date
* taking into account a custom timezone. If no
* <code>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 <code>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 <code>CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setDate(String parameterName, java.sql.Date x, Calendar cal)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given <code>java.sql.Time value.
* The driver converts this
* to an SQL <code>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 <code>CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setTime(String parameterName, java.sql.Time x)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given <code>java.sql.Time value,
* using the given <code>Calendar object. The driver uses
* the <code>Calendar object to construct an SQL TIME value,
* which the driver then sends to the database. With a
* a <code>Calendar object, the driver can calculate the time
* taking into account a custom timezone. If no
* <code>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 <code>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 <code>CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setTime(String parameterName, java.sql.Time x, Calendar cal)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given <code>java.sql.Timestamp value,
* using the given <code>Calendar object. The driver uses
* the <code>Calendar object to construct an SQL TIMESTAMP value,
* which the driver then sends to the database. With a
* a <code>Calendar object, the driver can calculate the timestamp
* taking into account a custom timezone. If no
* <code>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 <code>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 <code>CallableStatement
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
* @see #getParams
* @since 1.4
*/
public void setTimestamp(String parameterName, java.sql.Timestamp x, Calendar cal)
throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
/**
* Sets the designated parameter to the given <code>java.sql.SQLXML object. The driver converts this to an
* SQL <code>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 <code>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 <code>java.xml.transform.Result,
* <code>Writer or OutputStream has not been closed
* for the <code>SQLXML object or
* if there is an error processing the XML value. The <code>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 <code>java.sql.SQLXML object. The driver converts this to an
* <code>SQL XML value when it sends it to the database.
* @param parameterName the name of the parameter
* @param xmlObject a <code>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 <code>java.xml.transform.Result,
* <code>Writer or OutputStream has not been closed
* for the <code>SQLXML object or
* if there is an error processing the XML value. The <code>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 <code>java.sql.RowId object. The
* driver converts this to a SQL <code>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 <code>java.sql.RowId object. The
* driver converts this to a SQL <code>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 <code>String object.
* The driver converts this to a SQL <code>NCHAR or
* <code>NVARCHAR or LONGNVARCHAR value
* (depending on the argument's
* size relative to the driver's limits on <code>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 <code>String object.
* The driver converts this to a SQL <code>NCHAR or
* <code>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 <code>Reader object. The
* <code>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 <code>Reader object. The
* <code>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 <code>Reader object. The
* <code>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.
* <P>Note: This stream object can either be a standard
* Java stream object or your own subclass that implements the
* standard interface.
* <P>Note: Consult your JDBC driver documentation to determine if
* it might be more efficient to use a version of
* <code>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 <code>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 <code>java.sql.NClob object. The object
* implements the <code>java.sql.NClob interface. This NClob
* object maps to a SQL <code>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 <code>Reader object. The reader must contain
* the number
* of characters specified by length otherwise a <code>SQLException will be
* generated when the <code>CallableStatement is executed.
* This method differs from the <code>setCharacterStream (int, Reader, int) method
* because it informs the driver that the parameter value should be sent to
* the server as a <code>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 <code>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 <code>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 <code>Reader object.
* This method differs from the <code>setCharacterStream (int, Reader) method
* because it informs the driver that the parameter value should be sent to
* the server as a <code>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 <code>LONGNVARCHAR or a NCLOB
* <P>Note: Consult your JDBC driver documentation to determine if
* it might be more efficient to use a version of
* <code>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 <code>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 <code>Reader object. The reader must contain the number
* of characters specified by length otherwise a <code>SQLException will be
* generated when the <code>PreparedStatement is executed.
* This method differs from the <code>setCharacterStream (int, Reader, int) method
* because it informs the driver that the parameter value should be sent to
* the server as a <code>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 <code>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 <code>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 <code>java.sql.NClob object. The driver converts this oa
* SQL <code>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 <code>Reader object.
* This method differs from the <code>setCharacterStream (int, Reader) method
* because it informs the driver that the parameter value should be sent to
* the server as a <code>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 <code>LONGNVARCHAR or a NCLOB
* <P>Note: Consult your JDBC driver documentation to determine if
* it might be more efficient to use a version of
* <code>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 <code>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 <code>java.net.URL value.
* The driver converts this to an SQL <code>DATALINK value
* when it sends it to the database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the <code>java.net.URL object to be set
* @exception SQLException if a database access error occurs or
* this method is called on a closed <code>PreparedStatement
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
* @since 1.4
*/
public void setURL(int parameterIndex, java.net.URL x) throws SQLException{
throw new SQLFeatureNotSupportedException("Feature not supported");
}
static final long serialVersionUID = 4886719666485113312L;
} //end class
Other Java examples (source code examples)
Here is a short list of links related to this Java BaseRowSet.java source code file:
|
The search page
Other Java source code examples at this package level
Click here to learn more about this project
