History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/javax/sql/rowset/BaseRowSet.java (1 of 18352 files). Show all

Unified · Split

java/pkg/javax/sql/rowset/BaseRowSet.java+4512−0
@@ -0,0 +1,4512 @@
1+/*
2+ * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
3+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4+ *
5+ * This code is free software; you can redistribute it and/or modify it
6+ * under the terms of the GNU General Public License version 2 only, as
7+ * published by the Free Software Foundation. Oracle designates this
8+ * particular file as subject to the "Classpath" exception as provided
9+ * by Oracle in the LICENSE file that accompanied this code.
10+ *
11+ * This code is distributed in the hope that it will be useful, but WITHOUT
12+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14+ * version 2 for more details (a copy is included in the LICENSE file that
15+ * accompanied this code).
16+ *
17+ * You should have received a copy of the GNU General Public License version
18+ * 2 along with this work; if not, write to the Free Software Foundation,
19+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20+ *
21+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22+ * or visit www.oracle.com if you need additional information or have any
23+ * questions.
24+ */
25+
26+package javax.sql.rowset;
27+
28+import java.sql.*;
29+import javax.sql.*;
30+import java.util.*;
31+import java.io.*;
32+import java.math.*;
33+import java.io.Serializable;
34+
35+import javax.sql.rowset.serial.*;
36+
37+/**
38+ * An abstract class providing a <code>RowSet</code> object with its basic functionality.
39+ * The basic functions include having properties and sending event notifications,
40+ * which all JavaBeans<sup><font size=-2>TM</font></sup> components must implement.
41+ * <P>
42+ * <h3>1.0 Overview</h3>
43+ * The <code>BaseRowSet</code> class provides the core functionality
44+ * for all <code>RowSet</code> implementations,
45+ * and all standard implementations <b>may</b> use this class in combination with
46+ * one or more <code>RowSet</code> interfaces in order to provide a standard
47+ * vendor-specific implementation. To clarify, all implementations must implement
48+ * at least one of the <code>RowSet</code> interfaces (<code>JdbcRowSet</code>,
49+ * <code>CachedRowSet</code>, <code>JoinRowSet</code>, <code>FilteredRowSet</code>,
50+ * or <code>WebRowSet</code>). This means that any implementation that extends
51+ * the <code>BaseRowSet</code> class must also implement one of the <code>RowSet</code>
52+ * interfaces.
53+ * <p>
54+ * The <code>BaseRowSet</code> class provides the following:
55+ * <p>
56+ * <UL>
57+ * <LI><b>Properties</b>
58+ * <ul>
59+ * <li>Fields for storing current properties
60+ * <li>Methods for getting and setting properties
61+ * </ul>
62+ * <p>
63+ * <LI><b>Event notification</b>
64+ * <P>
65+ * <LI><b>A complete set of setter methods</b> for setting the parameters in a
66+ * <code>RowSet</code> object's command
67+ * <p>
68+ * <LI> <b>Streams</b>
69+ * <ul>
70+ * <li>Fields for storing stream instances
71+ * <li>Constants for indicating the type of a stream
72+ * </ul>
73+ * <p>
74+ * </UL>
75+ *
76+ * <h3>2.0 Setting Properties</h3>
77+ * All rowsets maintain a set of properties, which will usually be set using
78+ * a tool. The number and kinds of properties a rowset has will vary,
79+ * depending on what the <code>RowSet</code> implementation does and how it gets
80+ * its data. For example,
81+ * rowsets that get their data from a <code>ResultSet</code> object need to
82+ * set the properties that are required for making a database connection.
83+ * If a <code>RowSet</code> object uses the <code>DriverManager</code> facility to make a
84+ * connection, it needs to set a property for the JDBC URL that identifies the
85+ * appropriate driver, and it needs to set the properties that give the
86+ * user name and password.
87+ * If, on the other hand, the rowset uses a <code>DataSource</code> object
88+ * to make the connection, which is the preferred method, it does not need to
89+ * set the property for the JDBC URL. Instead, it needs to set the property
90+ * for the logical name of the data source along with the properties for
91+ * the user name and password.
92+ * <P>
93+ * NOTE: In order to use a <code>DataSource</code> object for making a
94+ * connection, the <code>DataSource</code> object must have been registered
95+ * with a naming service that uses the Java Naming and Directory
96+ * Interface<sup><font size=-2>TM</font></sup> (JNDI) API. This registration
97+ * is usually done by a person acting in the capacity of a system administrator.
98+ * <P>
99+ * <h3>3.0 Setting the Command and Its Parameters</h3>
100+ * When a rowset gets its data from a relational database, it executes a command (a query)
101+ * that produces a <code>ResultSet</code> object. This query is the command that is set
102+ * for the <code>RowSet</code> object's command property. The rowset populates itself with data by reading the
103+ * data from the <code>ResultSet</code> object into itself. If the query
104+ * contains placeholders for values to be set, the <code>BaseRowSet</code> setter methods
105+ * are used to set these values. All setter methods allow these values to be set
106+ * to <code>null</code> if required.
107+ * <P>
108+ * The following code fragment illustrates how the
109+ * <code>CachedRowSet</code><sup><font size=-2>TM</font></sup>
110+ * object <code>crs</code> might have its command property set. Note that if a
111+ * tool is used to set properties, this is the code that the tool would use.
112+ * <PRE>
113+ * crs.setCommand("SELECT FIRST_NAME, LAST_NAME, ADDRESS FROM CUSTOMERS" +
114+ * "WHERE CREDIT_LIMIT > ? AND REGION = ?");
115+ * </PRE>
116+ * <P>
117+ * In this example, the values for <code>CREDIT_LIMIT</code> and
118+ * <code>REGION</code> are placeholder parameters, which are indicated with a
119+ * question mark (?). The first question mark is placeholder parameter number
120+ * <code>1</code>, the second question mark is placeholder parameter number
121+ * <code>2</code>, and so on. Any placeholder parameters must be set with
122+ * values before the query can be executed. To set these
123+ * placeholder parameters, the <code>BaseRowSet</code> class provides a set of setter
124+ * methods, similar to those provided by the <code>PreparedStatement</code>
125+ * interface, for setting values of each data type. A <code>RowSet</code> object stores the
126+ * parameter values internally, and its <code>execute</code> method uses them internally
127+ * to set values for the placeholder parameters
128+ * before it sends the command to the DBMS to be executed.
129+ * <P>
130+ * The following code fragment demonstrates
131+ * setting the two parameters in the query from the previous example.
132+ * <PRE>
133+ * crs.setInt(1, 5000);
134+ * crs.setString(2, "West");
135+ * </PRE>
136+ * If the <code>execute</code> method is called at this point, the query
137+ * sent to the DBMS will be:
138+ * <PRE>
139+ * "SELECT FIRST_NAME, LAST_NAME, ADDRESS FROM CUSTOMERS" +
140+ * "WHERE CREDIT_LIMIT > 5000 AND REGION = 'West'"
141+ * </PRE>
142+ * NOTE: Setting <code>Array</code>, <code>Clob</code>, <code>Blob</code> and
143+ * <code>Ref</code> objects as a command parameter, stores these values as
144+ * <code>SerialArray</code>, <code>SerialClob</code>, <code>SerialBlob</code>
145+ * and <code>SerialRef</code> objects respectively.
146+ *
147+ * <h3>4.0 Handling of Parameters Behind the Scenes</h3>
148+ *
149+ * NOTE: The <code>BaseRowSet</code> class provides two kinds of setter methods,
150+ * those that set properties and those that set placeholder parameters. The setter
151+ * methods discussed in this section are those that set placeholder parameters.
152+ * <P>
153+ * The placeholder parameters set with the <code>BaseRowSet</code> setter methods
154+ * are stored as objects in an internal <code>Hashtable</code> object.
155+ * Primitives are stored as their <code>Object</code> type. For example, <code>byte</code>
156+ * is stored as <code>Byte</code> object, and <code>int</code> is stored as
157+ * an <code>Integer</code> object.
158+ * When the method <code>execute</code> is called, the values in the
159+ * <code>Hashtable</code> object are substituted for the appropriate placeholder
160+ * parameters in the command.
161+ * <P)>
162+ * A call to the method <code>getParams</code> returns the values stored in the
163+ * <code>Hashtable</code> object as an array of <code>Object</code> instances.
164+ * An element in this array may be a simple <code>Object</code> instance or an
165+ * array (which is a type of <code>Object</code>). The particular setter method used
166+ * determines whether an element in this array is an <code>Object</code> or an array.
167+ * <P>
168+ * The majority of methods for setting placeholder parameters take two parameters,
169+ * with the first parameter
170+ * indicating which placeholder parameter is to be set, and the second parameter
171+ * giving the value to be set. Methods such as <code>setInt</code>,
172+ * <code>setString</code>, <code>setBoolean</code>, and <code>setLong</code> fall into
173+ * this category. After these methods have been called, a call to the method
174+ * <code>getParams</code> will return an array with the values that have been set. Each
175+ * element in the array is an <code>Object</code> instance representing the
176+ * values that have been set. The order of these values in the array is determined by the
177+ * <code>int</code> (the first parameter) passed to the setter method. The values in the
178+ * array are the values (the second parameter) passed to the setter method.
179+ * In other words, the first element in the array is the value
180+ * to be set for the first placeholder parameter in the <code>RowSet</code> object's
181+ * command. The second element is the value to
182+ * be set for the second placeholder parameter, and so on.
183+ * <P>
184+ * Several setter methods send the driver and DBMS information beyond the value to be set.
185+ * When the method <code>getParams</code> is called after one of these setter methods has
186+ * been used, the elements in the array will themselves be arrays to accommodate the
187+ * additional information. In this category, the method <code>setNull</code> is a special case
188+ * because one version takes only
189+ * two parameters (<code>setNull(int parameterIndex, int SqlType)</code>). Nevertheless,
190+ * it requires
191+ * an array to contain the information that will be passed to the driver and DBMS. The first
192+ * element in this array is the value to be set, which is <code>null</code>, and the
193+ * second element is the <code>int</code> supplied for <i>sqlType</i>, which
194+ * indicates the type of SQL value that is being set to <code>null</code>. This information
195+ * is needed by some DBMSs and is therefore required in order to ensure that applications
196+ * are portable.
197+ * The other version is intended to be used when the value to be set to <code>null</code>
198+ * is a user-defined type. It takes three parameters
199+ * (<code>setNull(int parameterIndex, int sqlType, String typeName)</code>) and also
200+ * requires an array to contain the information to be passed to the driver and DBMS.
201+ * The first two elements in this array are the same as for the first version of
202+ * <code>setNull</code>. The third element, <i>typeName</i>, gives the SQL name of
203+ * the user-defined type. As is true with the other setter methods, the number of the
204+ * placeholder parameter to be set is indicated by an element's position in the array
205+ * returned by <code>getParams</code>. So, for example, if the parameter
206+ * supplied to <code>setNull</code> is <code>2</code>, the second element in the array
207+ * returned by <code>getParams</code> will be an array of two or three elements.
208+ * <P>
209+ * Some methods, such as <code>setObject</code> and <code>setDate</code> have versions
210+ * that take more than two parameters, with the extra parameters giving information
211+ * to the driver or the DBMS. For example, the methods <code>setDate</code>,
212+ * <code>setTime</code>, and <code>setTimestamp</code> can take a <code>Calendar</code>
213+ * object as their third parameter. If the DBMS does not store time zone information,
214+ * the drivern uses the <code>Calendar</code> object to construct the <code>Date</code>,
215+ * <code>Time</code>, or <code>Timestamp</code> object being set. As is true with other
216+ * methods that provide additional information, the element in the array returned
217+ * by <code>getParams</code> is an array instead of a simple <code>Object</code> instance.
218+ * <P>
219+ * The methods <code>setAsciiStream</code>, <code>setBinaryStream</code>,
220+ * <code>setCharacterStream</code>, and <code>setUnicodeStream</code> (which is
221+ * deprecated, so applications should use <code>getCharacterStream</code> instead)
222+ * take three parameters, so for them, the element in the array returned by
223+ * <code>getParams</code> is also an array. What is different about these setter
224+ * methods is that in addition to the information provided by parameters, the array contains
225+ * one of the <code>BaseRowSet</code> constants indicating the type of stream being set.
226+* <p>
227+* NOTE: The method <code>getParams</code> is called internally by
228+* <code>RowSet</code> implementations extending this class; it is not normally called by an
229+* application programmer directly.
230+*
231+* <h3>5.0 Event Notification</h3>
232+* The <code>BaseRowSet</code> class provides the event notification
233+* mechanism for rowsets. It contains the field
234+* <code>listeners</code>, methods for adding and removing listeners, and
235+* methods for notifying listeners of changes.
236+* <P>
237+* A listener is an object that has implemented the <code>RowSetListener</code> interface.
238+* If it has been added to a <code>RowSet</code> object's list of listeners, it will be notified
239+* when an event occurs on that <code>RowSet</code> object. Each listener's
240+* implementation of the <code>RowSetListener</code> methods defines what that object
241+* will do when it is notified that an event has occurred.
242+* <P>
243+* There are three possible events for a <code>RowSet</code> object:
244+* <OL>
245+* <LI>the cursor moves
246+* <LI>an individual row is changed (updated, deleted, or inserted)
247+* <LI>the contents of the entire <code>RowSet</code> object are changed
248+* </OL>
249+* <P>
250+* The <code>BaseRowSet</code> method used for the notification indicates the
251+* type of event that has occurred. For example, the method
252+* <code>notifyRowChanged</code> indicates that a row has been updated,
253+* deleted, or inserted. Each of the notification methods creates a
254+* <code>RowSetEvent</code> object, which is supplied to the listener in order to
255+* identify the <code>RowSet</code> object on which the event occurred.
256+* What the listener does with this information, which may be nothing, depends on how it was
257+* implemented.
258+* <p>
259+* <h3>6.0 Default Behavior</h3>
260+* A default <code>BaseRowSet</code> object is initialized with many starting values.
261+*
262+* The following is true of a default <code>RowSet</code> instance that extends
263+* the <code>BaseRowSet</code> class:
264+* <UL>
265+* <LI>Has a scrollable cursor and does not show changes
266+* made by others.
267+* <LI>Is updatable.
268+* <LI>Does not show rows that have been deleted.
269+* <LI>Has no time limit for how long a driver may take to
270+* execute the <code>RowSet</code> object's command.
271+* <LI>Has no limit for the number of rows it may contain.
272+* <LI>Has no limit for the number of bytes a column may contain. NOTE: This
273+* limit applies only to columns that hold values of the
274+* following types: <code>BINARY</code>, <code>VARBINARY</code>,
275+* <code>LONGVARBINARY</code>, <code>CHAR</code>, <code>VARCHAR</code>,
276+* and <code>LONGVARCHAR</code>.
277+* <LI>Will not see uncommitted data (make "dirty" reads).
278+* <LI>Has escape processing turned on.
279+* <LI>Has its connection's type map set to <code>null</code>.
280+* <LI>Has an empty <code>Vector</code> object for storing the values set
281+* for the placeholder parameters in the <code>RowSet</code> object's command.
282+* </UL>
283+* <p>
284+* If other values are desired, an application must set the property values
285+* explicitly. For example, the following line of code sets the maximum number
286+* of rows for the <code>CachedRowSet</code> object <i>crs</i> to 500.
287+* <PRE>
288+* crs.setMaxRows(500);
289+* </PRE>
290+* Methods implemented in extensions of this <code>BaseRowSet</code> class <b>must</b> throw an
291+* <code>SQLException</code> object for any violation of the defined assertions. Also, if the
292+* extending class overrides and reimplements any <code>BaseRowSet</code> method and encounters
293+* connectivity or underlying data source issues, that method <b>may</b> in addition throw an
294+* <code>SQLException</code> object for that reason.
295+*/
296+
297+public abstract class BaseRowSet implements Serializable, Cloneable {
298+
299+ /**
300+ * A constant indicating to a <code>RowSetReaderImpl</code> object
301+ * that a given parameter is a Unicode stream. This
302+ * <code>RowSetReaderImpl</code> object is provided as an extension of the
303+ * <code>SyncProvider</code> abstract class defined in the
304+ * <code>SyncFactory</code> static factory SPI mechanism.
305+ */
306+ public static final int UNICODE_STREAM_PARAM = 0;
307+
308+ /**
309+ * A constant indicating to a <code>RowSetReaderImpl</code> object
310+ * that a given parameter is a binary stream. A
311+ * <code>RowSetReaderImpl</code> object is provided as an extension of the
312+ * <code>SyncProvider</code> abstract class defined in the
313+ * <code>SyncFactory</code> static factory SPI mechanism.
314+ */
315+ public static final int BINARY_STREAM_PARAM = 1;
316+
317+ /**
318+ * A constant indicating to a <code>RowSetReaderImpl</code> object
319+ * that a given parameter is an ASCII stream. A
320+ * <code>RowSetReaderImpl</code> object is provided as an extension of the
321+ * <code>SyncProvider</code> abstract class defined in the
322+ * <code>SyncFactory</code> static factory SPI mechanism.
323+ */
324+ public static final int ASCII_STREAM_PARAM = 2;
325+
326+ /**
327+ * The <code>InputStream</code> object that will be
328+ * returned by the method <code>getBinaryStream</code>, which is
329+ * specified in the <code>ResultSet</code> interface.
330+ * @serial
331+ */
332+ protected java.io.InputStream binaryStream;
333+
334+ /**
335+ * The <code>InputStream</code> object that will be
336+ * returned by the method <code>getUnicodeStream</code>,
337+ * which is specified in the <code>ResultSet</code> interface.
338+ * @serial
339+ */
340+ protected java.io.InputStream unicodeStream;
341+
342+ /**
343+ * The <code>InputStream</code> object that will be
344+ * returned by the method <code>getAsciiStream</code>,
345+ * which is specified in the <code>ResultSet</code> interface.
346+ * @serial
347+ */
348+ protected java.io.InputStream asciiStream;
349+
350+ /**
351+ * The <code>Reader</code> object that will be
352+ * returned by the method <code>getCharacterStream</code>,
353+ * which is specified in the <code>ResultSet</code> interface.
354+ * @serial
355+ */
356+ protected java.io.Reader charStream;
357+
358+ /**
359+ * The query that will be sent to the DBMS for execution when the
360+ * method <code>execute</code> is called.
361+ * @serial
362+ */
363+ private String command;
364+
365+ /**
366+ * The JDBC URL the reader, writer, or both supply to the method
367+ * <code>DriverManager.getConnection</code> when the
368+ * <code>DriverManager</code> is used to get a connection.
369+ * <P>
370+ * The JDBC URL identifies the driver to be used to make the conndection.
371+ * This URL can be found in the documentation supplied by the driver
372+ * vendor.
373+ * @serial
374+ */
375+ private String URL;
376+
377+ /**
378+ * The logical name of the data source that the reader/writer should use
379+ * in order to retrieve a <code>DataSource</code> object from a Java
380+ * Directory and Naming Interface (JNDI) naming service.
381+ * @serial
382+ */
383+ private String dataSource;
384+
385+ /**
386+ * The user name the reader, writer, or both supply to the method
387+ * <code>DriverManager.getConnection</code> when the
388+ * <code>DriverManager</code> is used to get a connection.
389+ * @serial
390+ */
391+ private transient String username;
392+
393+ /**
394+ * The password the reader, writer, or both supply to the method
395+ * <code>DriverManager.getConnection</code> when the
396+ * <code>DriverManager</code> is used to get a connection.
397+ * @serial
398+ */
399+ private transient String password;
400+
401+ /**
402+ * A constant indicating the type of this JDBC <code>RowSet</code>
403+ * object. It must be one of the following <code>ResultSet</code>
404+ * constants: <code>TYPE_FORWARD_ONLY</code>,
405+ * <code>TYPE_SCROLL_INSENSITIVE</code>, or
406+ * <code>TYPE_SCROLL_SENSITIVE</code>.
407+ * @serial
408+ */
409+ private int rowSetType = ResultSet.TYPE_SCROLL_INSENSITIVE;
410+
411+ /**
412+ * A <code>boolean</code> indicating whether deleted rows are visible in this
413+ * JDBC <code>RowSet</code> object .
414+ * @serial
415+ */
416+ private boolean showDeleted = false; // default is false
417+
418+ /**
419+ * The maximum number of seconds the driver
420+ * will wait for a command to execute. This limit applies while
421+ * this JDBC <code>RowSet</code> object is connected to its data
422+ * source, that is, while it is populating itself with
423+ * data and while it is writing data back to the data source.
424+ * @serial
425+ */
426+ private int queryTimeout = 0; // default is no timeout
427+
428+ /**
429+ * The maximum number of rows the reader should read.
430+ * @serial
431+ */
432+ private int maxRows = 0; // default is no limit
433+
434+ /**
435+ * The maximum field size the reader should read.
436+ * @serial
437+ */
438+ private int maxFieldSize = 0; // default is no limit
439+
440+ /**
441+ * A constant indicating the concurrency of this JDBC <code>RowSet</code>
442+ * object. It must be one of the following <code>ResultSet</code>
443+ * constants: <code>CONCUR_READ_ONLY</code> or
444+ * <code>CONCUR_UPDATABLE</code>.
445+ * @serial
446+ */
447+ private int concurrency = ResultSet.CONCUR_UPDATABLE;
448+
449+ /**
450+ * A <code>boolean</code> indicating whether this JDBC <code>RowSet</code>
451+ * object is read-only. <code>true</code> indicates that it is read-only;
452+ * <code>false</code> that it is writable.
453+ * @serial
454+ */
455+ private boolean readOnly;
456+
457+ /**
458+ * A <code>boolean</code> indicating whether the reader for this
459+ * JDBC <code>RowSet</code> object should perform escape processing.
460+ * <code>true</code> means that escape processing is turned on;
461+ * <code>false</code> that it is not. The default is <code>true</code>.
462+ * @serial
463+ */
464+ private boolean escapeProcessing;
465+
466+ /**
467+ * A constant indicating the isolation level of the connection
468+ * for this JDBC <code>RowSet</code> object . It must be one of
469+ * the following <code>Connection</code> constants:
470+ * <code>TRANSACTION_NONE</code>,
471+ * <code>TRANSACTION_READ_UNCOMMITTED</code>,
472+ * <code>TRANSACTION_READ_COMMITTED</code>,
473+ * <code>TRANSACTION_REPEATABLE_READ</code> or
474+ * <code>TRANSACTION_SERIALIZABLE</code>.
475+ * @serial
476+ */
477+ private int isolation;
478+
479+ /**
480+ * A constant used as a hint to the driver that indicates the direction in
481+ * which data from this JDBC <code>RowSet</code> object is going
482+ * to be fetched. The following <code>ResultSet</code> constants are
483+ * possible values:
484+ * <code>FETCH_FORWARD</code>,
485+ * <code>FETCH_REVERSE</code>,
486+ * <code>FETCH_UNKNOWN</code>.
487+ * <P>
488+ * Unused at this time.
489+ * @serial
490+ */
491+ private int fetchDir = ResultSet.FETCH_FORWARD; // default fetch direction
492+
493+ /**
494+ * A hint to the driver that indicates the expected number of rows
495+ * in this JDBC <code>RowSet</code> object .
496+ * <P>
497+ * Unused at this time.
498+ * @serial
499+ */
500+ private int fetchSize = 0; // default fetchSize
501+
502+ /**
503+ * The <code>java.util.Map</code> object that contains entries mapping
504+ * SQL type names to classes in the Java programming language for the
505+ * custom mapping of user-defined types.
506+ * @serial
507+ */
508+ private Map<String, Class<?>> map;
509+
510+ /**
511+ * A <code>Vector</code> object that holds the list of listeners
512+ * that have registered with this <code>RowSet</code> object.
513+ * @serial
514+ */
515+ private Vector<RowSetListener> listeners;
516+
517+ /**
518+ * A <code>Vector</code> object that holds the parameters set
519+ * for this <code>RowSet</code> object's current command.
520+ * @serial
521+ */
522+ private Hashtable<Integer, Object> params; // could be transient?
523+
524+ /**
525+ * Constructs a new <code>BaseRowSet</code> object initialized with
526+ * a default <code>Vector</code> object for its <code>listeners</code>
527+ * field. The other default values with which it is initialized are listed
528+ * in Section 6.0 of the class comment for this class.
529+ */
530+ public BaseRowSet() {
531+ // allocate the listeners collection
532+ listeners = new Vector<RowSetListener>();
533+ }
534+
535+ /**
536+ * Performs the necessary internal configurations and initializations
537+ * to allow any JDBC <code>RowSet</code> implementation to start using
538+ * the standard facilities provided by a <code>BaseRowSet</code>
539+ * instance. This method <b>should</b> be called after the <code>RowSet</code> object
540+ * has been instantiated to correctly initialize all parameters. This method
541+ * <b>should</b> never be called by an application, but is called from with
542+ * a <code>RowSet</code> implementation extending this class.
543+ */
544+ protected void initParams() {
545+ params = new Hashtable<Integer, Object>();
546+ }
547+
548+ //--------------------------------------------------------------------
549+ // Events
550+ //--------------------------------------------------------------------
551+
552+ /**
553+ * The listener will be notified whenever an event occurs on this <code>RowSet</code>
554+ * object.
555+ * <P>
556+ * A listener might, for example, be a table or graph that needs to
557+ * be updated in order to accurately reflect the current state of
558+ * the <code>RowSet</code> object.
559+ * <p>
560+ * <b>Note</b>: if the <code>RowSetListener</code> object is
561+ * <code>null</code>, this method silently discards the <code>null</code>
562+ * value and does not add a null reference to the set of listeners.
563+ * <p>
564+ * <b>Note</b>: if the listener is already set, and the new <code>RowSetListerner</code>
565+ * instance is added to the set of listeners already registered to receive
566+ * event notifications from this <code>RowSet</code>.
567+ *
568+ * @param listener an object that has implemented the
569+ * <code>javax.sql.RowSetListener</code> interface and wants to be notified
570+ * of any events that occur on this <code>RowSet</code> object; May be
571+ * null.
572+ * @see #removeRowSetListener
573+ */
574+ public void addRowSetListener(RowSetListener listener) {
575+ listeners.add(listener);
576+ }
577+
578+ /**
579+ * Removes the designated object from this <code>RowSet</code> object's list of listeners.
580+ * If the given argument is not a registered listener, this method
581+ * does nothing.
582+ *
583+ * <b>Note</b>: if the <code>RowSetListener</code> object is
584+ * <code>null</code>, this method silently discards the <code>null</code>
585+ * value.
586+ *
587+ * @param listener a <code>RowSetListener</code> object that is on the list
588+ * of listeners for this <code>RowSet</code> object
589+ * @see #addRowSetListener
590+ */
591+ public void removeRowSetListener(RowSetListener listener) {
592+ listeners.remove(listener);
593+ }
594+
595+ /**
596+ * Determine if instance of this class extends the RowSet interface.
597+ */
598+ private void checkforRowSetInterface() throws SQLException {
599+ if ((this instanceof javax.sql.RowSet) == false) {
600+ throw new SQLException("The class extending abstract class BaseRowSet " +
601+ "must implement javax.sql.RowSet or one of it's sub-interfaces.");
602+ }
603+ }
604+
605+ /**
606+ * Notifies all of the listeners registered with this
607+ * <code>RowSet</code> object that its cursor has moved.
608+ * <P>
609+ * When an application calls a method to move the cursor,
610+ * that method moves the cursor and then calls this method
611+ * internally. An application <b>should</b> never invoke
612+ * this method directly.
613+ *
614+ * @throws SQLException if the class extending the <code>BaseRowSet</code>
615+ * abstract class does not implement the <code>RowSet</code> interface or
616+ * one of it's sub-interfaces.
617+ */
618+ protected void notifyCursorMoved() throws SQLException {
619+ checkforRowSetInterface();
620+ if (listeners.isEmpty() == false) {
621+ RowSetEvent event = new RowSetEvent((RowSet)this);
622+ for (Iterator i = listeners.iterator(); i.hasNext(); ) {
623+ ((RowSetListener)i.next()).cursorMoved(event);
624+ }
625+ }
626+ }
627+
628+ /**
629+ * Notifies all of the listeners registered with this <code>RowSet</code> object that
630+ * one of its rows has changed.
631+ * <P>
632+ * When an application calls a method that changes a row, such as
633+ * the <code>CachedRowSet</code> methods <code>insertRow</code>,
634+ * <code>updateRow</code>, or <code>deleteRow</code>,
635+ * that method calls <code>notifyRowChanged</code>
636+ * internally. An application <b>should</b> never invoke
637+ * this method directly.
638+ *
639+ * @throws SQLException if the class extending the <code>BaseRowSet</code>
640+ * abstract class does not implement the <code>RowSet</code> interface or
641+ * one of it's sub-interfaces.
642+ */
643+ protected void notifyRowChanged() throws SQLException {
644+ checkforRowSetInterface();
645+ if (listeners.isEmpty() == false) {
646+ RowSetEvent event = new RowSetEvent((RowSet)this);
647+ for (Iterator i = listeners.iterator(); i.hasNext(); ) {
648+ ((RowSetListener)i.next()).rowChanged(event);
649+ }
650+ }
651+ }
652+
653+ /**
654+ * Notifies all of the listeners registered with this <code>RowSet</code>
655+ * object that its entire contents have changed.
656+ * <P>
657+ * When an application calls methods that change the entire contents
658+ * of the <code>RowSet</code> object, such as the <code>CachedRowSet</code> methods
659+ * <code>execute</code>, <code>populate</code>, <code>restoreOriginal</code>,
660+ * or <code>release</code>, that method calls <code>notifyRowSetChanged</code>
661+ * internally (either directly or indirectly). An application <b>should</b>
662+ * never invoke this method directly.
663+ *
664+ * @throws SQLException if the class extending the <code>BaseRowSet</code>
665+ * abstract class does not implement the <code>RowSet</code> interface or
666+ * one of it's sub-interfaces.
667+ */
668+ protected void notifyRowSetChanged() throws SQLException {
669+ checkforRowSetInterface();
670+ if (listeners.isEmpty() == false) {
671+ RowSetEvent event = new RowSetEvent((RowSet)this);
672+ for (Iterator i = listeners.iterator(); i.hasNext(); ) {
673+ ((RowSetListener)i.next()).rowSetChanged(event);
674+ }
675+ }
676+}
677+
678+ /**
679+ * Retrieves the SQL query that is the command for this
680+ * <code>RowSet</code> object. The command property contains the query that
681+ * will be executed to populate this <code>RowSet</code> object.
682+ * <P>
683+ * The SQL query returned by this method is used by <code>RowSet</code> methods
684+ * such as <code>execute</code> and <code>populate</code>, which may be implemented
685+ * by any class that extends the <code>BaseRowSet</code> abstract class and
686+ * implements one or more of the standard JSR-114 <code>RowSet</code>
687+ * interfaces.
688+ * <P>
689+ * The command is used by the <code>RowSet</code> object's
690+ * reader to obtain a <code>ResultSet</code> object. The reader then
691+ * reads the data from the <code>ResultSet</code> object and uses it to
692+ * to populate this <code>RowSet</code> object.
693+ * <P>
694+ * The default value for the <code>command</code> property is <code>null</code>.
695+ *
696+ * @return the <code>String</code> that is the value for this
697+ * <code>RowSet</code> object's <code>command</code> property;
698+ * may be <code>null</code>
699+ * @see #setCommand
700+ */
701+ public String getCommand() {
702+ return command;
703+ }
704+
705+ /**
706+ * Sets this <code>RowSet</code> object's <code>command</code> property to
707+ * the given <code>String</code> object and clears the parameters, if any,
708+ * that were set for the previous command.
709+ * <P>
710+ * The <code>command</code> property may not be needed if the <code>RowSet</code>
711+ * object gets its data from a source that does not support commands,
712+ * such as a spreadsheet or other tabular file.
713+ * Thus, this property is optional and may be <code>null</code>.
714+ *
715+ * @param cmd a <code>String</code> object containing an SQL query
716+ * that will be set as this <code>RowSet</code> object's command
717+ * property; may be <code>null</code> but may not be an empty string
718+ * @throws SQLException if an empty string is provided as the command value
719+ * @see #getCommand
720+ */
721+ public void setCommand(String cmd) throws SQLException {
722+ // cmd equal to null or
723+ // cmd with length 0 (implies url =="")
724+ // are not independent events.
725+
726+ if(cmd == null) {
727+ command = null;
728+ } else if (cmd.length() == 0) {
729+ throw new SQLException("Invalid command string detected. " +
730+ "Cannot be of length less than 0");
731+ } else {
732+ // "unbind" any parameters from any previous command.
733+ if(params == null){
734+ throw new SQLException("Set initParams() before setCommand");
735+ }
736+ params.clear();
737+ command = cmd;
738+ }
739+
740+ }
741+
742+ /**
743+ * Retrieves the JDBC URL that this <code>RowSet</code> object's
744+ * <code>javax.sql.Reader</code> object uses to make a connection
745+ * with a relational database using a JDBC technology-enabled driver.
746+ *<P>
747+ * The <code>Url</code> property will be <code>null</code> if the underlying data
748+ * source is a non-SQL data source, such as a spreadsheet or an XML
749+ * data source.
750+ *
751+ * @return a <code>String</code> object that contains the JDBC URL
752+ * used to establish the connection for this <code>RowSet</code>
753+ * object; may be <code>null</code> (default value) if not set
754+ * @throws SQLException if an error occurs retrieving the URL value
755+ * @see #setUrl
756+ */
757+ public String getUrl() throws SQLException {
758+ return URL;
759+ }
760+
761+ /**
762+ * Sets the Url property for this <code>RowSet</code> object
763+ * to the given <code>String</code> object and sets the dataSource name
764+ * property to <code>null</code>. The Url property is a
765+ * JDBC URL that is used when
766+ * the connection is created using a JDBC technology-enabled driver
767+ * ("JDBC driver") and the <code>DriverManager</code>.
768+ * The correct JDBC URL for the specific driver to be used can be found
769+ * in the driver documentation. Although there are guidelines for for how
770+ * a JDBC URL is formed,
771+ * a driver vendor can specify any <code>String</code> object except
772+ * one with a length of <code>0</code> (an empty string).
773+ * <P>
774+ * Setting the Url property is optional if connections are established using
775+ * a <code>DataSource</code> object instead of the <code>DriverManager</code>.
776+ * The driver will use either the URL property or the
777+ * dataSourceName property to create a connection, whichever was
778+ * specified most recently. If an application uses a JDBC URL, it
779+ * must load a JDBC driver that accepts the JDBC URL before it uses the
780+ * <code>RowSet</code> object to connect to a database. The <code>RowSet</code>
781+ * object will use the URL internally to create a database connection in order
782+ * to read or write data.
783+ *
784+ * @param url a <code>String</code> object that contains the JDBC URL
785+ * that will be used to establish the connection to a database for this
786+ * <code>RowSet</code> object; may be <code>null</code> but must not
787+ * be an empty string
788+ * @throws SQLException if an error occurs setting the Url property or the
789+ * parameter supplied is a string with a length of <code>0</code> (an
790+ * empty string)
791+ * @see #getUrl
792+ */
793+ public void setUrl(String url) throws SQLException {
794+ if(url == null) {
795+ url = null;
796+ } else if (url.length() < 1) {
797+ throw new SQLException("Invalid url string detected. " +
798+ "Cannot be of length less than 1");
799+ } else {
800+ URL = url;
801+ }
802+
803+ dataSource = null;
804+
805+ }
806+
807+ /**
808+ * Returns the logical name that when supplied to a naming service
809+ * that uses the Java Naming and Directory Interface (JNDI) API, will
810+ * retrieve a <code>javax.sql.DataSource</code> object. This
811+ * <code>DataSource</code> object can be used to establish a connection
812+ * to the data source that it represents.
813+ * <P>
814+ * Users should set either the url or the data source name property.
815+ * The driver will use the property set most recently to establish a
816+ * connection.
817+ *
818+ * @return a <code>String</code> object that identifies the
819+ * <code>DataSource</code> object to be used for making a
820+ * connection; if no logical name has been set, <code>null</code>
821+ * is returned.
822+ * @see #setDataSourceName
823+ */
824+ public String getDataSourceName() {
825+ return dataSource;
826+ }
827+
828+
829+ /**
830+ * Sets the <code>DataSource</code> name property for this <code>RowSet</code>
831+ * object to the given logical name and sets this <code>RowSet</code> object's
832+ * Url property to <code>null</code>. The name must have been bound to a
833+ * <code>DataSource</code> object in a JNDI naming service so that an
834+ * application can do a lookup using that name to retrieve the
835+ * <code>DataSource</code> object bound to it. The <code>DataSource</code>
836+ * object can then be used to establish a connection to the data source it
837+ * represents.
838+ * <P>
839+ * Users should set either the Url property or the dataSourceName property.
840+ * If both properties are set, the driver will use the property set most recently.
841+ *
842+ * @param name a <code>String</code> object with the name that can be supplied
843+ * to a naming service based on JNDI technology to retrieve the
844+ * <code>DataSource</code> object that can be used to get a connection;
845+ * may be <code>null</code> but must not be an empty string
846+ * @throws SQLException if an empty string is provided as the <code>DataSource</code>
847+ * name
848+ * @see #getDataSourceName
849+ */
850+ public void setDataSourceName(String name) throws SQLException {
851+
852+ if (name == null) {
853+ dataSource = null;
854+ } else if (name.equals("")) {
855+ throw new SQLException("DataSource name cannot be empty string");
856+ } else {
857+ dataSource = name;
858+ }
859+
860+ URL = null;
861+ }
862+
863+ /**
864+ * Returns the user name used to create a database connection. Because it
865+ * is not serialized, the username property is set at runtime before
866+ * calling the method <code>execute</code>.
867+ *
868+ * @return the <code>String</code> object containing the user name that
869+ * is supplied to the data source to create a connection; may be
870+ * <code>null</code> (default value) if not set
871+ * @see #setUsername
872+ */
873+ public String getUsername() {
874+ return username;
875+ }
876+
877+ /**
878+ * Sets the username property for this <code>RowSet</code> object
879+ * to the given user name. Because it
880+ * is not serialized, the username property is set at run time before
881+ * calling the method <code>execute</code>.
882+ *
883+ * @param name the <code>String</code> object containing the user name that
884+ * is supplied to the data source to create a connection. It may be null.
885+ * @see #getUsername
886+ */
887+ public void setUsername(String name) {
888+ if(name == null)
889+ {
890+ username = null;
891+ } else {
892+ username = name;
893+ }
894+ }
895+
896+ /**
897+ * Returns the password used to create a database connection for this
898+ * <code>RowSet</code> object. Because the password property is not
899+ * serialized, it is set at run time before calling the method
900+ * <code>execute</code>. The default value is <code>null</code>
901+ *
902+ * @return the <code>String</code> object that represents the password
903+ * that must be supplied to the database to create a connection
904+ * @see #setPassword
905+ */
906+ public String getPassword() {
907+ return password;
908+ }
909+
910+ /**
911+ * Sets the password used to create a database connection for this
912+ * <code>RowSet</code> object to the given <code>String</code>
913+ * object. Because the password property is not
914+ * serialized, it is set at run time before calling the method
915+ * <code>execute</code>.
916+ *
917+ * @param pass the <code>String</code> object that represents the password
918+ * that is supplied to the database to create a connection. It may be
919+ * null.
920+ * @see #getPassword
921+ */
922+ public void setPassword(String pass) {
923+ if(pass == null)
924+ {
925+ password = null;
926+ } else {
927+ password = pass;
928+ }
929+ }
930+
931+ /**
932+ * Sets the type for this <code>RowSet</code> object to the specified type.
933+ * The default type is <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>.
934+ *
935+ * @param type one of the following constants:
936+ * <code>ResultSet.TYPE_FORWARD_ONLY</code>,
937+ * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
938+ * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
939+ * @throws SQLException if the parameter supplied is not one of the
940+ * following constants:
941+ * <code>ResultSet.TYPE_FORWARD_ONLY</code> or
942+ * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>
943+ * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
944+ * @see #getConcurrency
945+ * @see #getType
946+ */
947+ public void setType(int type) throws SQLException {
948+
949+ if ((type != ResultSet.TYPE_FORWARD_ONLY) &&
950+ (type != ResultSet.TYPE_SCROLL_INSENSITIVE) &&
951+ (type != ResultSet.TYPE_SCROLL_SENSITIVE)) {
952+ throw new SQLException("Invalid type of RowSet set. Must be either " +
953+ "ResultSet.TYPE_FORWARD_ONLY or ResultSet.TYPE_SCROLL_INSENSITIVE " +
954+ "or ResultSet.TYPE_SCROLL_SENSITIVE.");
955+ }
956+ this.rowSetType = type;
957+ }
958+
959+ /**
960+ * Returns the type of this <code>RowSet</code> object. The type is initially
961+ * determined by the statement that created the <code>RowSet</code> object.
962+ * The <code>RowSet</code> object can call the method
963+ * <code>setType</code> at any time to change its
964+ * type. The default is <code>TYPE_SCROLL_INSENSITIVE</code>.
965+ *
966+ * @return the type of this JDBC <code>RowSet</code>
967+ * object, which must be one of the following:
968+ * <code>ResultSet.TYPE_FORWARD_ONLY</code>,
969+ * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
970+ * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
971+ * @throws SQLException if an error occurs getting the type of
972+ * of this <code>RowSet</code> object
973+ * @see #setType
974+ */
975+ public int getType() throws SQLException {
976+ return rowSetType;
977+ }
978+
979+ /**
980+ * Sets the concurrency for this <code>RowSet</code> object to
981+ * the specified concurrency. The default concurrency for any <code>RowSet</code>
982+ * object (connected or disconnected) is <code>ResultSet.CONCUR_UPDATABLE</code>,
983+ * but this method may be called at any time to change the concurrency.
984+ * <P>
985+ * @param concurrency one of the following constants:
986+ * <code>ResultSet.CONCUR_READ_ONLY</code> or
987+ * <code>ResultSet.CONCUR_UPDATABLE</code>
988+ * @throws SQLException if the parameter supplied is not one of the
989+ * following constants:
990+ * <code>ResultSet.CONCUR_UPDATABLE</code> or
991+ * <code>ResultSet.CONCUR_READ_ONLY</code>
992+ * @see #getConcurrency
993+ * @see #isReadOnly
994+ */
995+ public void setConcurrency(int concurrency) throws SQLException {
996+
997+ if((concurrency != ResultSet.CONCUR_READ_ONLY) &&
998+ (concurrency != ResultSet.CONCUR_UPDATABLE)) {
999+ throw new SQLException("Invalid concurrency set. Must be either " +
1000+ "ResultSet.CONCUR_READ_ONLY or ResultSet.CONCUR_UPDATABLE.");
1001+ }
1002+ this.concurrency = concurrency;
1003+ }
1004+
1005+ /**
1006+ * Returns a <code>boolean</code> indicating whether this
1007+ * <code>RowSet</code> object is read-only.
1008+ * Any attempts to update a read-only <code>RowSet</code> object will result in an
1009+ * <code>SQLException</code> being thrown. By default,
1010+ * rowsets are updatable if updates are possible.
1011+ *
1012+ * @return <code>true</code> if this <code>RowSet</code> object
1013+ * cannot be updated; <code>false</code> otherwise
1014+ * @see #setConcurrency
1015+ * @see #setReadOnly
1016+ */
1017+ public boolean isReadOnly() {
1018+ return readOnly;
1019+ };
1020+
1021+ /**
1022+ * Sets this <code>RowSet</code> object's readOnly property to the given <code>boolean</code>.
1023+ *
1024+ * @param value <code>true</code> to indicate that this
1025+ * <code>RowSet</code> object is read-only;
1026+ * <code>false</code> to indicate that it is updatable
1027+ */
1028+ public void setReadOnly(boolean value) {
1029+ readOnly = value;
1030+ }
1031+
1032+ /**
1033+ * Returns the transaction isolation property for this
1034+ * <code>RowSet</code> object's connection. This property represents
1035+ * the transaction isolation level requested for use in transactions.
1036+ * <P>
1037+ * For <code>RowSet</code> implementations such as
1038+ * the <code>CachedRowSet</code> that operate in a disconnected environment,
1039+ * the <code>SyncProvider</code> object
1040+ * offers complementary locking and data integrity options. The
1041+ * options described below are pertinent only to connected <code>RowSet</code>
1042+ * objects (<code>JdbcRowSet</code> objects).
1043+ *
1044+ * @return one of the following constants:
1045+ * <code>Connection.TRANSACTION_NONE</code>,
1046+ * <code>Connection.TRANSACTION_READ_UNCOMMITTED</code>,
1047+ * <code>Connection.TRANSACTION_READ_COMMITTED</code>,
1048+ * <code>Connection.TRANSACTION_REPEATABLE_READ</code>, or
1049+ * <code>Connection.TRANSACTION_SERIALIZABLE</code>
1050+ * @see javax.sql.rowset.spi.SyncFactory
1051+ * @see javax.sql.rowset.spi.SyncProvider
1052+ * @see #setTransactionIsolation
1053+
1054+ */
1055+ public int getTransactionIsolation() {
1056+ return isolation;
1057+ };
1058+
1059+ /**
1060+ * Sets the transaction isolation property for this JDBC <code>RowSet</code> object to the given
1061+ * constant. The DBMS will use this transaction isolation level for
1062+ * transactions if it can.
1063+ * <p>
1064+ * For <code>RowSet</code> implementations such as
1065+ * the <code>CachedRowSet</code> that operate in a disconnected environment,
1066+ * the <code>SyncProvider</code> object being used
1067+ * offers complementary locking and data integrity options. The
1068+ * options described below are pertinent only to connected <code>RowSet</code>
1069+ * objects (<code>JdbcRowSet</code> objects).
1070+ *
1071+ * @param level one of the following constants, listed in ascending order:
1072+ * <code>Connection.TRANSACTION_NONE</code>,
1073+ * <code>Connection.TRANSACTION_READ_UNCOMMITTED</code>,
1074+ * <code>Connection.TRANSACTION_READ_COMMITTED</code>,
1075+ * <code>Connection.TRANSACTION_REPEATABLE_READ</code>, or
1076+ * <code>Connection.TRANSACTION_SERIALIZABLE</code>
1077+ * @throws SQLException if the given parameter is not one of the Connection
1078+ * constants
1079+ * @see javax.sql.rowset.spi.SyncFactory
1080+ * @see javax.sql.rowset.spi.SyncProvider
1081+ * @see #getTransactionIsolation
1082+ */
1083+ public void setTransactionIsolation(int level) throws SQLException {
1084+ if ((level != Connection.TRANSACTION_NONE) &&
1085+ (level != Connection.TRANSACTION_READ_COMMITTED) &&
1086+ (level != Connection.TRANSACTION_READ_UNCOMMITTED) &&
1087+ (level != Connection.TRANSACTION_REPEATABLE_READ) &&
1088+ (level != Connection.TRANSACTION_SERIALIZABLE))
1089+ {
1090+ throw new SQLException("Invalid transaction isolation set. Must " +
1091+ "be either " +
1092+ "Connection.TRANSACTION_NONE or " +
1093+ "Connection.TRANSACTION_READ_UNCOMMITTED or " +
1094+ "Connection.TRANSACTION_READ_COMMITTED or " +
1095+ "Connection.RRANSACTION_REPEATABLE_READ or " +
1096+ "Connection.TRANSACTION_SERIALIZABLE");
1097+ }
1098+ this.isolation = level;
1099+ }
1100+
1101+ /**
1102+ * Retrieves the type map associated with the <code>Connection</code>
1103+ * object for this <code>RowSet</code> object.
1104+ * <P>
1105+ * Drivers that support the JDBC 3.0 API will create
1106+ * <code>Connection</code> objects with an associated type map.
1107+ * This type map, which is initially empty, can contain one or more
1108+ * fully-qualified SQL names and <code>Class</code> objects indicating
1109+ * the class to which the named SQL value will be mapped. The type mapping
1110+ * specified in the connection's type map is used for custom type mapping
1111+ * when no other type map supersedes it.
1112+ * <p>
1113+ * If a type map is explicitly supplied to a method that can perform
1114+ * custom mapping, that type map supersedes the connection's type map.
1115+ *
1116+ * @return the <code>java.util.Map</code> object that is the type map
1117+ * for this <code>RowSet</code> object's connection
1118+ */
1119+ public java.util.Map<String,Class<?>> getTypeMap() {
1120+ return map;
1121+ }
1122+
1123+ /**
1124+ * Installs the given <code>java.util.Map</code> object as the type map
1125+ * associated with the <code>Connection</code> object for this
1126+ * <code>RowSet</code> object. The custom mapping indicated in
1127+ * this type map will be used unless a different type map is explicitly
1128+ * supplied to a method, in which case the type map supplied will be used.
1129+ *
1130+ * @param map a <code>java.util.Map</code> object that contains the
1131+ * mapping from SQL type names for user defined types (UDT) to classes in
1132+ * the Java programming language. Each entry in the <code>Map</code>
1133+ * object consists of the fully qualified SQL name of a UDT and the
1134+ * <code>Class</code> object for the <code>SQLData</code> implementation
1135+ * of that UDT. May be <code>null</code>.
1136+ */
1137+ public void setTypeMap(java.util.Map<String,Class<?>> map) {
1138+ this.map = map;
1139+ }
1140+
1141+ /**
1142+ * Retrieves the maximum number of bytes that can be used for a column
1143+ * value in this <code>RowSet</code> object.
1144+ * This limit applies only to columns that hold values of the
1145+ * following types: <code>BINARY</code>, <code>VARBINARY</code>,
1146+ * <code>LONGVARBINARY</code>, <code>CHAR</code>, <code>VARCHAR</code>,
1147+ * and <code>LONGVARCHAR</code>. If the limit is exceeded, the excess
1148+ * data is silently discarded.
1149+ *
1150+ * @return an <code>int</code> indicating the current maximum column size
1151+ * limit; zero means that there is no limit
1152+ * @throws SQLException if an error occurs internally determining the
1153+ * maximum limit of the column size
1154+ */
1155+ public int getMaxFieldSize() throws SQLException {
1156+ return maxFieldSize;
1157+ }
1158+
1159+ /**
1160+ * Sets the maximum number of bytes that can be used for a column
1161+ * value in this <code>RowSet</code> object to the given number.
1162+ * This limit applies only to columns that hold values of the
1163+ * following types: <code>BINARY</code>, <code>VARBINARY</code>,
1164+ * <code>LONGVARBINARY</code>, <code>CHAR</code>, <code>VARCHAR</code>,
1165+ * and <code>LONGVARCHAR</code>. If the limit is exceeded, the excess
1166+ * data is silently discarded. For maximum portability, it is advisable to
1167+ * use values greater than 256.
1168+ *
1169+ * @param max an <code>int</code> indicating the new maximum column size
1170+ * limit; zero means that there is no limit
1171+ * @throws SQLException if (1) an error occurs internally setting the
1172+ * maximum limit of the column size or (2) a size of less than 0 is set
1173+ */
1174+ public void setMaxFieldSize(int max) throws SQLException {
1175+ if (max < 0) {
1176+ throw new SQLException("Invalid max field size set. Cannot be of " +
1177+ "value: " + max);
1178+ }
1179+ maxFieldSize = max;
1180+ }
1181+
1182+ /**
1183+ * Retrieves the maximum number of rows that this <code>RowSet</code> object may contain. If
1184+ * this limit is exceeded, the excess rows are silently dropped.
1185+ *
1186+ * @return an <code>int</code> indicating the current maximum number of
1187+ * rows; zero means that there is no limit
1188+ * @throws SQLException if an error occurs internally determining the
1189+ * maximum limit of rows that a <code>Rowset</code> object can contain
1190+ */
1191+ public int getMaxRows() throws SQLException {
1192+ return maxRows;
1193+ }
1194+
1195+ /**
1196+ * Sets the maximum number of rows that this <code>RowSet</code> object may contain to
1197+ * the given number. If this limit is exceeded, the excess rows are
1198+ * silently dropped.
1199+ *
1200+ * @param max an <code>int</code> indicating the current maximum number
1201+ * of rows; zero means that there is no limit
1202+ * @throws SQLException if an error occurs internally setting the
1203+ * maximum limit on the number of rows that a JDBC <code>RowSet</code> object
1204+ * can contain; or if <i>max</i> is less than <code>0</code>; or
1205+ * if <i>max</i> is less than the <code>fetchSize</code> of the
1206+ * <code>RowSet</code>
1207+ */
1208+ public void setMaxRows(int max) throws SQLException {
1209+ if (max < 0) {
1210+ throw new SQLException("Invalid max row size set. Cannot be of " +
1211+ "value: " + max);
1212+ } else if (max < this.getFetchSize()) {
1213+ throw new SQLException("Invalid max row size set. Cannot be less " +
1214+ "than the fetchSize.");
1215+ }
1216+ this.maxRows = max;
1217+ }
1218+
1219+ /**
1220+ * Sets to the given <code>boolean</code> whether or not the driver will
1221+ * scan for escape syntax and do escape substitution before sending SQL
1222+ * statements to the database. The default is for the driver to do escape
1223+ * processing.
1224+ * <P>
1225+ * Note: Since <code>PreparedStatement</code> objects have usually been
1226+ * parsed prior to making this call, disabling escape processing for
1227+ * prepared statements will likely have no effect.
1228+ *
1229+ * @param enable <code>true</code> to enable escape processing;
1230+ * <code>false</code> to disable it
1231+ * @throws SQLException if an error occurs setting the underlying JDBC
1232+ * technology-enabled driver to process the escape syntax
1233+ */
1234+ public void setEscapeProcessing(boolean enable) throws SQLException {
1235+ escapeProcessing = enable;
1236+ }
1237+
1238+ /**
1239+ * Retrieves the maximum number of seconds the driver will wait for a
1240+ * query to execute. If the limit is exceeded, an <code>SQLException</code>
1241+ * is thrown.
1242+ *
1243+ * @return the current query timeout limit in seconds; zero means that
1244+ * there is no limit
1245+ * @throws SQLException if an error occurs in determining the query
1246+ * time-out value
1247+ */
1248+ public int getQueryTimeout() throws SQLException {
1249+ return queryTimeout;
1250+ }
1251+
1252+ /**
1253+ * Sets to the given number the maximum number of seconds the driver will
1254+ * wait for a query to execute. If the limit is exceeded, an
1255+ * <code>SQLException</code> is thrown.
1256+ *
1257+ * @param seconds the new query time-out limit in seconds; zero means that
1258+ * there is no limit; must not be less than zero
1259+ * @throws SQLException if an error occurs setting the query
1260+ * time-out or if the query time-out value is less than 0
1261+ */
1262+ public void setQueryTimeout(int seconds) throws SQLException {
1263+ if (seconds < 0) {
1264+ throw new SQLException("Invalid query timeout value set. Cannot be " +
1265+ "of value: " + seconds);
1266+ }
1267+ this.queryTimeout = seconds;
1268+ }
1269+
1270+ /**
1271+ * Retrieves a <code>boolean</code> indicating whether rows marked
1272+ * for deletion appear in the set of current rows.
1273+ * The default value is <code>false</code>.
1274+ * <P>
1275+ * Note: Allowing deleted rows to remain visible complicates the behavior
1276+ * of some of the methods. However, most <code>RowSet</code> object users
1277+ * can simply ignore this extra detail because only sophisticated
1278+ * applications will likely want to take advantage of this feature.
1279+ *
1280+ * @return <code>true</code> if deleted rows are visible;
1281+ * <code>false</code> otherwise
1282+ * @throws SQLException if an error occurs determining if deleted rows
1283+ * are visible or not
1284+ * @see #setShowDeleted
1285+ */
1286+ public boolean getShowDeleted() throws SQLException {
1287+ return showDeleted;
1288+ }
1289+
1290+ /**
1291+ * Sets the property <code>showDeleted</code> to the given
1292+ * <code>boolean</code> value, which determines whether
1293+ * rows marked for deletion appear in the set of current rows.
1294+ *
1295+ * @param value <code>true</code> if deleted rows should be shown;
1296+ * <code>false</code> otherwise
1297+ * @throws SQLException if an error occurs setting whether deleted
1298+ * rows are visible or not
1299+ * @see #getShowDeleted
1300+ */
1301+ public void setShowDeleted(boolean value) throws SQLException {
1302+ showDeleted = value;
1303+ }
1304+
1305+ /**
1306+ * Ascertains whether escape processing is enabled for this
1307+ * <code>RowSet</code> object.
1308+ *
1309+ * @return <code>true</code> if escape processing is turned on;
1310+ * <code>false</code> otherwise
1311+ * @throws SQLException if an error occurs determining if escape
1312+ * processing is enabled or not or if the internal escape
1313+ * processing trigger has not been enabled
1314+ */
1315+ public boolean getEscapeProcessing() throws SQLException {
1316+ return escapeProcessing;
1317+ }
1318+
1319+ /**
1320+ * Gives the driver a performance hint as to the direction in
1321+ * which the rows in this <code>RowSet</code> object will be
1322+ * processed. The driver may ignore this hint.
1323+ * <P>
1324+ * A <code>RowSet</code> object inherits the default properties of the
1325+ * <code>ResultSet</code> object from which it got its data. That
1326+ * <code>ResultSet</code> object's default fetch direction is set by
1327+ * the <code>Statement</code> object that created it.
1328+ * <P>
1329+ * This method applies to a <code>RowSet</code> object only while it is
1330+ * connected to a database using a JDBC driver.
1331+ * <p>
1332+ * A <code>RowSet</code> object may use this method at any time to change
1333+ * its setting for the fetch direction.
1334+ *
1335+ * @param direction one of <code>ResultSet.FETCH_FORWARD</code>,
1336+ * <code>ResultSet.FETCH_REVERSE</code>, or
1337+ * <code>ResultSet.FETCH_UNKNOWN</code>
1338+ * @throws SQLException if (1) the <code>RowSet</code> type is
1339+ * <code>TYPE_FORWARD_ONLY</code> and the given fetch direction is not
1340+ * <code>FETCH_FORWARD</code> or (2) the given fetch direction is not
1341+ * one of the following:
1342+ * ResultSet.FETCH_FORWARD,
1343+ * ResultSet.FETCH_REVERSE, or
1344+ * ResultSet.FETCH_UNKNOWN
1345+ * @see #getFetchDirection
1346+ */
1347+ public void setFetchDirection(int direction) throws SQLException {
1348+ // Changed the condition checking to the below as there were two
1349+ // conditions that had to be checked
1350+ // 1. RowSet is TYPE_FORWARD_ONLY and direction is not FETCH_FORWARD
1351+ // 2. Direction is not one of the valid values
1352+
1353+ if (((getType() == ResultSet.TYPE_FORWARD_ONLY) && (direction != ResultSet.FETCH_FORWARD)) ||
1354+ ((direction != ResultSet.FETCH_FORWARD) &&
1355+ (direction != ResultSet.FETCH_REVERSE) &&
1356+ (direction != ResultSet.FETCH_UNKNOWN))) {
1357+ throw new SQLException("Invalid Fetch Direction");
1358+ }
1359+ fetchDir = direction;
1360+ }
1361+
1362+ /**
1363+ * Retrieves this <code>RowSet</code> object's current setting for the
1364+ * fetch direction. The default type is <code>ResultSet.FETCH_FORWARD</code>
1365+ *
1366+ * @return one of <code>ResultSet.FETCH_FORWARD</code>,
1367+ * <code>ResultSet.FETCH_REVERSE</code>, or
1368+ * <code>ResultSet.FETCH_UNKNOWN</code>
1369+ * @throws SQLException if an error occurs in determining the
1370+ * current fetch direction for fetching rows
1371+ * @see #setFetchDirection
1372+ */
1373+ public int getFetchDirection() throws SQLException {
1374+
1375+ //Added the following code to throw a
1376+ //SQL Exception if the fetchDir is not
1377+ //set properly.Bug id:4914155
1378+
1379+ // This checking is not necessary!
1380+
1381+ /*
1382+ if((fetchDir != ResultSet.FETCH_FORWARD) &&
1383+ (fetchDir != ResultSet.FETCH_REVERSE) &&
1384+ (fetchDir != ResultSet.FETCH_UNKNOWN)) {
1385+ throw new SQLException("Fetch Direction Invalid");
1386+ }
1387+ */
1388+ return (fetchDir);
1389+ }
1390+
1391+ /**
1392+ * Sets the fetch size for this <code>RowSet</code> object to the given number of
1393+ * rows. The fetch size gives a JDBC technology-enabled driver ("JDBC driver")
1394+ * a hint as to the
1395+ * number of rows that should be fetched from the database when more rows
1396+ * are needed for this <code>RowSet</code> object. If the fetch size specified
1397+ * is zero, the driver ignores the value and is free to make its own best guess
1398+ * as to what the fetch size should be.
1399+ * <P>
1400+ * A <code>RowSet</code> object inherits the default properties of the
1401+ * <code>ResultSet</code> object from which it got its data. That
1402+ * <code>ResultSet</code> object's default fetch size is set by
1403+ * the <code>Statement</code> object that created it.
1404+ * <P>
1405+ * This method applies to a <code>RowSet</code> object only while it is
1406+ * connected to a database using a JDBC driver.
1407+ * For connected <code>RowSet</code> implementations such as
1408+ * <code>JdbcRowSet</code>, this method has a direct and immediate effect
1409+ * on the underlying JDBC driver.
1410+ * <P>
1411+ * A <code>RowSet</code> object may use this method at any time to change
1412+ * its setting for the fetch size.
1413+ * <p>
1414+ * For <code>RowSet</code> implementations such as
1415+ * <code>CachedRowSet</code>, which operate in a disconnected environment,
1416+ * the <code>SyncProvider</code> object being used
1417+ * may leverage the fetch size to poll the data source and
1418+ * retrieve a number of rows that do not exceed the fetch size and that may
1419+ * form a subset of the actual rows returned by the original query. This is
1420+ * an implementation variance determined by the specific <code>SyncProvider</code>
1421+ * object employed by the disconnected <code>RowSet</code> object.
1422+ * <P>
1423+ *
1424+ * @param rows the number of rows to fetch; <code>0</code> to let the
1425+ * driver decide what the best fetch size is; must not be less
1426+ * than <code>0</code> or more than the maximum number of rows
1427+ * allowed for this <code>RowSet</code> object (the number returned
1428+ * by a call to the method {@link #getMaxRows})
1429+ * @throws SQLException if the specified fetch size is less than <code>0</code>
1430+ * or more than the limit for the maximum number of rows
1431+ * @see #getFetchSize
1432+ */
1433+ public void setFetchSize(int rows) throws SQLException {
1434+ //Added this checking as maxRows can be 0 when this function is called
1435+ //maxRows = 0 means rowset can hold any number of rows, os this checking
1436+ // is needed to take care of this condition.
1437+ if (getMaxRows() == 0 && rows >= 0) {
1438+ fetchSize = rows;
1439+ return;
1440+ }
1441+ if ((rows < 0) || (rows > getMaxRows())) {
1442+ throw new SQLException("Invalid fetch size set. Cannot be of " +
1443+ "value: " + rows);
1444+ }
1445+ fetchSize = rows;
1446+ }
1447+
1448+ /**
1449+ * Returns the fetch size for this <code>RowSet</code> object. The default
1450+ * value is zero.
1451+ *
1452+ * @return the number of rows suggested as the fetch size when this <code>RowSet</code> object
1453+ * needs more rows from the database
1454+ * @throws SQLException if an error occurs determining the number of rows in the
1455+ * current fetch size
1456+ * @see #setFetchSize
1457+ */
1458+ public int getFetchSize() throws SQLException {
1459+ return fetchSize;
1460+ }
1461+
1462+ /**
1463+ * Returns the concurrency for this <code>RowSet</code> object.
1464+ * The default is <code>CONCUR_UPDATABLE</code> for both connected and
1465+ * disconnected <code>RowSet</code> objects.
1466+ * <P>
1467+ * An application can call the method <code>setConcurrency</code> at any time
1468+ * to change a <code>RowSet</code> object's concurrency.
1469+ * <p>
1470+ * @return the concurrency type for this <code>RowSet</code>
1471+ * object, which must be one of the following:
1472+ * <code>ResultSet.CONCUR_READ_ONLY</code> or
1473+ * <code>ResultSet.CONCUR_UPDATABLE</code>
1474+ * @throws SQLException if an error occurs getting the concurrency
1475+ * of this <code>RowSet</code> object
1476+ * @see #setConcurrency
1477+ * @see #isReadOnly
1478+ */
1479+ public int getConcurrency() throws SQLException {
1480+ return concurrency;
1481+ }
1482+
1483+ //-----------------------------------------------------------------------
1484+ // Parameters
1485+ //-----------------------------------------------------------------------
1486+
1487+ /**
1488+ * Checks the given index to see whether it is less than <code>1</code> and
1489+ * throws an <code>SQLException</code> object if it is.
1490+ * <P>
1491+ * This method is called by many methods internally; it is never
1492+ * called by an application directly.
1493+ *
1494+ * @param idx an <code>int</code> indicating which parameter is to be
1495+ * checked; the first parameter is <code>1</code>
1496+ * @throws SQLException if the parameter is less than <code>1</code>
1497+ */
1498+ private void checkParamIndex(int idx) throws SQLException {
1499+ if ((idx < 1)) {
1500+ throw new SQLException("Invalid Parameter Index");
1501+ }
1502+ }
1503+
1504+ //---------------------------------------------------------------------
1505+ // setter methods for setting the parameters in a <code>RowSet</code> object's command
1506+ //---------------------------------------------------------------------
1507+
1508+ /**
1509+ * Sets the designated parameter to SQL <code>NULL</code>.
1510+ * Note that the parameter's SQL type must be specified using one of the
1511+ * type codes defined in <code>java.sql.Types</code>. This SQL type is
1512+ * specified in the second parameter.
1513+ * <p>
1514+ * Note that the second parameter tells the DBMS the data type of the value being
1515+ * set to <code>NULL</code>. Some DBMSs require this information, so it is required
1516+ * in order to make code more portable.
1517+ * <P>
1518+ * The parameter value set by this method is stored internally and
1519+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
1520+ * object's command when the method <code>execute</code> is called.
1521+ * Methods such as <code>execute</code> and <code>populate</code> must be
1522+ * provided in any class that extends this class and implements one or
1523+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
1524+ * <P>
1525+ * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
1526+ * as it is undefined in this class.
1527+ * <P>
1528+ * Calls made to the method <code>getParams</code> after this version of
1529+ * <code>setNull</code>
1530+ * has been called will return an <code>Object</code> array containing the parameter values that
1531+ * have been set. In that array, the element that represents the values
1532+ * set with this method will itself be an array. The first element of that array
1533+ * is <code>null</code>.
1534+ * The second element is the value set for <i>sqlType</i>.
1535+ * The parameter number is indicated by an element's position in the array
1536+ * returned by the method <code>getParams</code>,
1537+ * with the first element being the value for the first placeholder parameter, the
1538+ * second element being the value for the second placeholder parameter, and so on.
1539+ * In other words, if the second placeholder parameter is being set to
1540+ * <code>null</code>, the array containing it will be the second element in
1541+ * the array returned by <code>getParams</code>.
1542+ * <P>
1543+ * Note that because the numbering of elements in an array starts at zero,
1544+ * the array element that corresponds to placeholder parameter number
1545+ * <i>parameterIndex</i> is <i>parameterIndex</i> -1.
1546+ *
1547+ * @param parameterIndex the ordinal number of the placeholder parameter
1548+ * in this <code>RowSet</code> object's command that is to be set.
1549+ * The first parameter is 1, the second is 2, and so on; must be
1550+ * <code>1</code> or greater
1551+ * @param sqlType an <code>int</code> that is one of the SQL type codes
1552+ * defined in the class {@link java.sql.Types}. If a non-standard
1553+ * <i>sqlType</i> is supplied, this method will not throw a
1554+ * <code>SQLException</code>. This allows implicit support for
1555+ * non-standard SQL types.
1556+ * @throws SQLException if a database access error occurs or the given
1557+ * parameter index is out of bounds
1558+ * @see #getParams
1559+ */
1560+ public void setNull(int parameterIndex, int sqlType) throws SQLException {
1561+ Object nullVal[];
1562+ checkParamIndex(parameterIndex);
1563+
1564+ nullVal = new Object[2];
1565+ nullVal[0] = null;
1566+ nullVal[1] = Integer.valueOf(sqlType);
1567+
1568+ if (params == null){
1569+ throw new SQLException("Set initParams() before setNull");
1570+ }
1571+
1572+ params.put(Integer.valueOf(parameterIndex - 1), nullVal);
1573+ }
1574+
1575+ /**
1576+ * Sets the designated parameter to SQL <code>NULL</code>.
1577+ *
1578+ * Although this version of the method <code>setNull</code> is intended
1579+ * for user-defined
1580+ * and <code>REF</code> parameters, this method may be used to set a null
1581+ * parameter for any JDBC type. The following are user-defined types:
1582+ * <code>STRUCT</code>, <code>DISTINCT</code>, and <code>JAVA_OBJECT</code>,
1583+ * and named array types.
1584+ *
1585+ * <P><B>Note:</B> To be portable, applications must give the
1586+ * SQL type code and the fully qualified SQL type name when specifying
1587+ * a <code>NULL</code> user-defined or <code>REF</code> parameter.
1588+ * In the case of a user-defined type, the name is the type name of
1589+ * the parameter itself. For a <code>REF</code> parameter, the name is
1590+ * the type name of the referenced type. If a JDBC technology-enabled
1591+ * driver does not need the type code or type name information,
1592+ * it may ignore it.
1593+ * <P>
1594+ * If the parameter does not have a user-defined or <code>REF</code> type,
1595+ * the given <code>typeName</code> parameter is ignored.
1596+ * <P>
1597+ * The parameter value set by this method is stored internally and
1598+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
1599+ * object's command when the method <code>execute</code> is called.
1600+ * Methods such as <code>execute</code> and <code>populate</code> must be
1601+ * provided in any class that extends this class and implements one or
1602+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
1603+ * <P>
1604+ * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
1605+ * as it is undefined in this class.
1606+ * <P>
1607+ * Calls made to the method <code>getParams</code> after this version of
1608+ * <code>setNull</code>
1609+ * has been called will return an <code>Object</code> array containing the parameter values that
1610+ * have been set. In that array, the element that represents the values
1611+ * set with this method will itself be an array. The first element of that array
1612+ * is <code>null</code>.
1613+ * The second element is the value set for <i>sqlType</i>, and the third
1614+ * element is the value set for <i>typeName</i>.
1615+ * The parameter number is indicated by an element's position in the array
1616+ * returned by the method <code>getParams</code>,
1617+ * with the first element being the value for the first placeholder parameter, the
1618+ * second element being the value for the second placeholder parameter, and so on.
1619+ * In other words, if the second placeholder parameter is being set to
1620+ * <code>null</code>, the array containing it will be the second element in
1621+ * the array returned by <code>getParams</code>.
1622+ * <P>
1623+ * Note that because the numbering of elements in an array starts at zero,
1624+ * the array element that corresponds to placeholder parameter number
1625+ * <i>parameterIndex</i> is <i>parameterIndex</i> -1.
1626+ *
1627+ * @param parameterIndex the ordinal number of the placeholder parameter
1628+ * in this <code>RowSet</code> object's command that is to be set.
1629+ * The first parameter is 1, the second is 2, and so on; must be
1630+ * <code>1</code> or greater
1631+ * @param sqlType a value from <code>java.sql.Types</code>
1632+ * @param typeName the fully qualified name of an SQL user-defined type,
1633+ * which is ignored if the parameter is not a user-defined
1634+ * type or <code>REF</code> value
1635+ * @throws SQLException if an error occurs or the given parameter index
1636+ * is out of bounds
1637+ * @see #getParams
1638+ */
1639+ public void setNull(int parameterIndex, int sqlType, String typeName)
1640+ throws SQLException {
1641+
1642+ Object nullVal[];
1643+ checkParamIndex(parameterIndex);
1644+
1645+ nullVal = new Object[3];
1646+ nullVal[0] = null;
1647+ nullVal[1] = Integer.valueOf(sqlType);
1648+ nullVal[2] = typeName;
1649+
1650+ if(params == null){
1651+ throw new SQLException("Set initParams() before setNull");
1652+ }
1653+
1654+ params.put(Integer.valueOf(parameterIndex - 1), nullVal);
1655+ }
1656+
1657+
1658+ /**
1659+ * Sets the designated parameter to the given <code>boolean</code> in the
1660+ * Java programming language. The driver converts this to an SQL
1661+ * <code>BIT</code> value when it sends it to the database.
1662+ * <P>
1663+ * The parameter value set by this method is stored internally and
1664+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
1665+ * object's command when the method <code>execute</code> is called.
1666+ * Methods such as <code>execute</code>, <code>populate</code> must be
1667+ * provided in any class that extends this class and implements one or
1668+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
1669+ * <p>
1670+ * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
1671+ * as it is undefined in this class.
1672+ *
1673+ * @param parameterIndex the ordinal number of the placeholder parameter
1674+ * in this <code>RowSet</code> object's command that is to be set.
1675+ * The first parameter is 1, the second is 2, and so on; must be
1676+ * <code>1</code> or greater
1677+ * @param x the parameter value
1678+ * @throws SQLException if an error occurs or the
1679+ * parameter index is out of bounds
1680+ * @see #getParams
1681+ */
1682+ public void setBoolean(int parameterIndex, boolean x) throws SQLException {
1683+ checkParamIndex(parameterIndex);
1684+
1685+ if(params == null){
1686+ throw new SQLException("Set initParams() before setNull");
1687+ }
1688+
1689+ params.put(Integer.valueOf(parameterIndex - 1), Boolean.valueOf(x));
1690+ }
1691+
1692+ /**
1693+ * Sets the designated parameter to the given <code>byte</code> in the Java
1694+ * programming language. The driver converts this to an SQL
1695+ * <code>TINYINT</code> value when it sends it to the database.
1696+ * <P>
1697+ * The parameter value set by this method is stored internally and
1698+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
1699+ * object's command when the method <code>execute</code> is called.
1700+ * Methods such as <code>execute</code> and <code>populate</code> must be
1701+ * provided in any class that extends this class and implements one or
1702+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
1703+ * <p>
1704+ * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
1705+ * as it is undefined in this class.
1706+ *
1707+ * @param parameterIndex the ordinal number of the placeholder parameter
1708+ * in this <code>RowSet</code> object's command that is to be set.
1709+ * The first parameter is 1, the second is 2, and so on; must be
1710+ * <code>1</code> or greater
1711+ * @param x the parameter value
1712+ * @throws SQLException if an error occurs or the
1713+ * parameter index is out of bounds
1714+ * @see #getParams
1715+ */
1716+ public void setByte(int parameterIndex, byte x) throws SQLException {
1717+ checkParamIndex(parameterIndex);
1718+
1719+ if(params == null){
1720+ throw new SQLException("Set initParams() before setByte");
1721+ }
1722+
1723+ params.put(Integer.valueOf(parameterIndex - 1), Byte.valueOf(x));
1724+ }
1725+
1726+ /**
1727+ * Sets the designated parameter to the given <code>short</code> in the
1728+ * Java programming language. The driver converts this to an SQL
1729+ * <code>SMALLINT</code> value when it sends it to the database.
1730+ * <P>
1731+ * The parameter value set by this method is stored internally and
1732+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
1733+ * object's command when the method <code>execute</code> is called.
1734+ * Methods such as <code>execute</code> and <code>populate</code> must be
1735+ * provided in any class that extends this class and implements one or
1736+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
1737+ * <p>
1738+ * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
1739+ * as it is undefined in this class.
1740+ * <p>
1741+ * @param parameterIndex the ordinal number of the placeholder parameter
1742+ * in this <code>RowSet</code> object's command that is to be set.
1743+ * The first parameter is 1, the second is 2, and so on; must be
1744+ * <code>1</code> or greater
1745+ * @param x the parameter value
1746+ * @throws SQLException if an error occurs or the
1747+ * parameter index is out of bounds
1748+ * @see #getParams
1749+ */
1750+ public void setShort(int parameterIndex, short x) throws SQLException {
1751+ checkParamIndex(parameterIndex);
1752+
1753+ if(params == null){
1754+ throw new SQLException("Set initParams() before setShort");
1755+ }
1756+
1757+ params.put(Integer.valueOf(parameterIndex - 1), Short.valueOf(x));
1758+ }
1759+
1760+ /**
1761+ * Sets the designated parameter to an <code>int</code> in the Java
1762+ * programming language. The driver converts this to an SQL
1763+ * <code>INTEGER</code> value when it sends it to the database.
1764+ * <P>
1765+ * The parameter value set by this method is stored internally and
1766+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
1767+ * object's command when the method <code>execute</code> is called.
1768+ * Methods such as <code>execute</code> and <code>populate</code> must be
1769+ * provided in any class that extends this class and implements one or
1770+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
1771+ * <P>
1772+ * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
1773+ * as it is undefined in this class.
1774+ *
1775+ * @param parameterIndex the ordinal number of the placeholder parameter
1776+ * in this <code>RowSet</code> object's command that is to be set.
1777+ * The first parameter is 1, the second is 2, and so on; must be
1778+ * <code>1</code> or greater
1779+ * @param x the parameter value
1780+ * @throws SQLException if an error occurs or the
1781+ * parameter index is out of bounds
1782+ * @see #getParams
1783+ */
1784+ public void setInt(int parameterIndex, int x) throws SQLException {
1785+ checkParamIndex(parameterIndex);
1786+ if(params == null){
1787+ throw new SQLException("Set initParams() before setInt");
1788+ }
1789+ params.put(Integer.valueOf(parameterIndex - 1), Integer.valueOf(x));
1790+ }
1791+
1792+ /**
1793+ * Sets the designated parameter to the given <code>long</code> in the Java
1794+ * programming language. The driver converts this to an SQL
1795+ * <code>BIGINT</code> value when it sends it to the database.
1796+ * <P>
1797+ * The parameter value set by this method is stored internally and
1798+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
1799+ * object's command when the method <code>execute</code> is called.
1800+ * Methods such as <code>execute</code> and <code>populate</code> must be
1801+ * provided in any class that extends this class and implements one or
1802+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
1803+ * <P>
1804+ * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
1805+ * as it is undefined in this class.
1806+ *
1807+ * @param parameterIndex the ordinal number of the placeholder parameter
1808+ * in this <code>RowSet</code> object's command that is to be set.
1809+ * The first parameter is 1, the second is 2, and so on; must be
1810+ * <code>1</code> or greater
1811+ * @param x the parameter value
1812+ * @throws SQLException if an error occurs or the
1813+ * parameter index is out of bounds
1814+ * @see #getParams
1815+ */
1816+ public void setLong(int parameterIndex, long x) throws SQLException {
1817+ checkParamIndex(parameterIndex);
1818+ if(params == null){
1819+ throw new SQLException("Set initParams() before setLong");
1820+ }
1821+ params.put(Integer.valueOf(parameterIndex - 1), Long.valueOf(x));
1822+ }
1823+
1824+ /**
1825+ * Sets the designated parameter to the given <code>float</code> in the
1826+ * Java programming language. The driver converts this to an SQL
1827+ * <code>FLOAT</code> value when it sends it to the database.
1828+ * <P>
1829+ * The parameter value set by this method is stored internally and
1830+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
1831+ * object's command when the method <code>execute</code> is called.
1832+ * Methods such as <code>execute</code> and <code>populate</code> must be
1833+ * provided in any class that extends this class and implements one or
1834+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
1835+ * <P>
1836+ * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
1837+ * as it is undefined in this class.
1838+ *
1839+ * @param parameterIndex the ordinal number of the placeholder parameter
1840+ * in this <code>RowSet</code> object's command that is to be set.
1841+ * The first parameter is 1, the second is 2, and so on; must be
1842+ * <code>1</code> or greater
1843+ * @param x the parameter value
1844+ * @throws SQLException if an error occurs or the
1845+ * parameter index is out of bounds
1846+ * @see #getParams
1847+ */
1848+ public void setFloat(int parameterIndex, float x) throws SQLException {
1849+ checkParamIndex(parameterIndex);
1850+ if(params == null){
1851+ throw new SQLException("Set initParams() before setFloat");
1852+ }
1853+ params.put(Integer.valueOf(parameterIndex - 1), new Float(x));
1854+ }
1855+
1856+ /**
1857+ * Sets the designated parameter to the given <code>double</code> in the
1858+ * Java programming language. The driver converts this to an SQL
1859+ * <code>DOUBLE</code> value when it sends it to the database.
1860+ * <P>
1861+ * The parameter value set by this method is stored internally and
1862+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
1863+ * object's command when the method <code>execute</code> is called.
1864+ * Methods such as <code>execute</code> and <code>populate</code> must be
1865+ * provided in any class that extends this class and implements one or
1866+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
1867+ * <P>
1868+ * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
1869+ * as it is undefined in this class.
1870+ * S
1871+ * @param parameterIndex the ordinal number of the placeholder parameter
1872+ * in this <code>RowSet</code> object's command that is to be set.
1873+ * The first parameter is 1, the second is 2, and so on; must be
1874+ * <code>1</code> or greater
1875+ * @param x the parameter value
1876+ * @throws SQLException if an error occurs or the
1877+ * parameter index is out of bounds
1878+ * @see #getParams
1879+ */
1880+ public void setDouble(int parameterIndex, double x) throws SQLException {
1881+ checkParamIndex(parameterIndex);
1882+ if(params == null){
1883+ throw new SQLException("Set initParams() before setDouble");
1884+ }
1885+ params.put(Integer.valueOf(parameterIndex - 1), new Double(x));
1886+ }
1887+
1888+ /**
1889+ * Sets the designated parameter to the given
1890+ * <code>java.lang.BigDecimal</code> value. The driver converts this to
1891+ * an SQL <code>NUMERIC</code> value when it sends it to the database.
1892+ * <P>
1893+ * The parameter value set by this method is stored internally and
1894+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
1895+ * object's command when the method <code>execute</code> is called.
1896+ * Methods such as <code>execute</code> and <code>populate</code> must be
1897+ * provided in any class that extends this class and implements one or
1898+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
1899+ * <P>
1900+ * Note: <code>JdbcRowSet</code> does not require the <code>populate</code> method
1901+ * as it is undefined in this class.
1902+ *
1903+ * @param parameterIndex the ordinal number of the placeholder parameter
1904+ * in this <code>RowSet</code> object's command that is to be set.
1905+ * The first parameter is 1, the second is 2, and so on; must be
1906+ * <code>1</code> or greater
1907+ * @param x the parameter value
1908+ * @throws SQLException if an error occurs or the
1909+ * parameter index is out of bounds
1910+ * @see #getParams
1911+ */
1912+ public void setBigDecimal(int parameterIndex, java.math.BigDecimal x) throws SQLException {
1913+ checkParamIndex(parameterIndex);
1914+ if(params == null){
1915+ throw new SQLException("Set initParams() before setBigDecimal");
1916+ }
1917+ params.put(Integer.valueOf(parameterIndex - 1), x);
1918+ }
1919+
1920+ /**
1921+ * Sets the designated parameter to the given <code>String</code>
1922+ * value. The driver converts this to an SQL
1923+ * <code>VARCHAR</code> or <code>LONGVARCHAR</code> value
1924+ * (depending on the argument's size relative to the driver's limits
1925+ * on <code>VARCHAR</code> values) when it sends it to the database.
1926+ * <P>
1927+ * The parameter value set by this method is stored internally and
1928+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
1929+ * object's command when the method <code>execute</code> is called.
1930+ * Methods such as <code>execute</code> and <code>populate</code> must be
1931+ * provided in any class that extends this class and implements one or
1932+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
1933+ * <p>
1934+ * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
1935+ * as it is undefined in this class.
1936+ * <p>
1937+ * @param parameterIndex the ordinal number of the placeholder parameter
1938+ * in this <code>RowSet</code> object's command that is to be set.
1939+ * The first parameter is 1, the second is 2, and so on; must be
1940+ * <code>1</code> or greater
1941+ * @param x the parameter value
1942+ * @throws SQLException if an error occurs or the
1943+ * parameter index is out of bounds
1944+ * @see #getParams
1945+ */
1946+ public void setString(int parameterIndex, String x) throws SQLException {
1947+ checkParamIndex(parameterIndex);
1948+ if(params == null){
1949+ throw new SQLException("Set initParams() before setString");
1950+ }
1951+ params.put(Integer.valueOf(parameterIndex - 1), x);
1952+ }
1953+
1954+ /**
1955+ * Sets the designated parameter to the given array of bytes.
1956+ * The driver converts this to an SQL
1957+ * <code>VARBINARY</code> or <code>LONGVARBINARY</code> value
1958+ * (depending on the argument's size relative to the driver's limits
1959+ * on <code>VARBINARY</code> values) when it sends it to the database.
1960+ * <P>
1961+ * The parameter value set by this method is stored internally and
1962+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
1963+ * object's command when the method <code>execute</code> is called.
1964+ * Methods such as <code>execute</code> and <code>populate</code> must be
1965+ * provided in any class that extends this class and implements one or
1966+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
1967+ * <p>
1968+ * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
1969+ * as it is undefined in this class.
1970+ *
1971+ * @param parameterIndex the ordinal number of the placeholder parameter
1972+ * in this <code>RowSet</code> object's command that is to be set.
1973+ * The first parameter is 1, the second is 2, and so on; must be
1974+ * <code>1</code> or greater
1975+ * @param x the parameter value
1976+ * @throws SQLException if an error occurs or the
1977+ * parameter index is out of bounds
1978+ * @see #getParams
1979+ */
1980+ public void setBytes(int parameterIndex, byte x[]) throws SQLException {
1981+ checkParamIndex(parameterIndex);
1982+ if(params == null){
1983+ throw new SQLException("Set initParams() before setBytes");
1984+ }
1985+ params.put(Integer.valueOf(parameterIndex - 1), x);
1986+ }
1987+
1988+ /**
1989+ * Sets the designated parameter to the given <code>java.sql.Date</code>
1990+ * value. The driver converts this to an SQL
1991+ * <code>DATE</code> value when it sends it to the database.
1992+ * <P>
1993+ * The parameter value set by this method is stored internally and
1994+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
1995+ * object's command when the method <code>execute</code> is called.
1996+ * Methods such as <code>execute</code> and <code>populate</code> must be
1997+ * provided in any class that extends this class and implements one or
1998+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
1999+ * <P>
2000+ * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2001+ * as it is undefined in this class.
2002+ * <P>
2003+ * Calls made to the method <code>getParams</code> after this version
2004+ * of <code>setDate</code>
2005+ * has been called will return an array with the value to be set for
2006+ * placeholder parameter number <i>parameterIndex</i> being the <code>Date</code>
2007+ * object supplied as the second parameter.
2008+ * Note that because the numbering of elements in an array starts at zero,
2009+ * the array element that corresponds to placeholder parameter number
2010+ * <i>parameterIndex</i> is <i>parameterIndex</i> -1.
2011+ *
2012+ * @param parameterIndex the ordinal number of the placeholder parameter
2013+ * in this <code>RowSet</code> object's command that is to be set.
2014+ * The first parameter is 1, the second is 2, and so on; must be
2015+ * <code>1</code> or greater
2016+ * @param x the parameter value
2017+ * @throws SQLException if an error occurs or the
2018+ * parameter index is out of bounds
2019+ * @see #getParams
2020+ */
2021+ public void setDate(int parameterIndex, java.sql.Date x) throws SQLException {
2022+ checkParamIndex(parameterIndex);
2023+
2024+ if(params == null){
2025+ throw new SQLException("Set initParams() before setDate");
2026+ }
2027+ params.put(Integer.valueOf(parameterIndex - 1), x);
2028+ }
2029+
2030+ /**
2031+ * Sets the designated parameter to the given <code>java.sql.Time</code>
2032+ * value. The driver converts this to an SQL <code>TIME</code> value
2033+ * when it sends it to the database.
2034+ * <P>
2035+ * The parameter value set by this method is stored internally and
2036+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
2037+ * object's command when the method <code>execute</code> is called.
2038+ * Methods such as <code>execute</code> and <code>populate</code> must be
2039+ * provided in any class that extends this class and implements one or
2040+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
2041+ * <P>
2042+ * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2043+ * as it is undefined in this class.
2044+ * <P>
2045+ * Calls made to the method <code>getParams</code> after this version
2046+ * of the method <code>setTime</code>
2047+ * has been called will return an array of the parameters that have been set.
2048+ * The parameter to be set for parameter placeholder number <i>parameterIndex</i>
2049+ * will be the <code>Time</code> object that was set as the second parameter
2050+ * to this method.
2051+ * <P>
2052+ * Note that because the numbering of elements in an array starts at zero,
2053+ * the array element that corresponds to placeholder parameter number
2054+ * <i>parameterIndex</i> is <i>parameterIndex</i> -1.
2055+ *
2056+ * @param parameterIndex the ordinal number of the placeholder parameter
2057+ * in this <code>RowSet</code> object's command that is to be set.
2058+ * The first parameter is 1, the second is 2, and so on; must be
2059+ * <code>1</code> or greater
2060+ * @param x a <code>java.sql.Time</code> object, which is to be set as the value
2061+ * for placeholder parameter <i>parameterIndex</i>
2062+ * @throws SQLException if an error occurs or the
2063+ * parameter index is out of bounds
2064+ * @see #getParams
2065+ */
2066+ public void setTime(int parameterIndex, java.sql.Time x) throws SQLException {
2067+ checkParamIndex(parameterIndex);
2068+ if(params == null){
2069+ throw new SQLException("Set initParams() before setTime");
2070+ }
2071+
2072+ params.put(Integer.valueOf(parameterIndex - 1), x);
2073+ }
2074+
2075+ /**
2076+ * Sets the designated parameter to the given
2077+ * <code>java.sql.Timestamp</code> value.
2078+ * The driver converts this to an SQL <code>TIMESTAMP</code> value when it
2079+ * sends it to the database.
2080+ * <P>
2081+ * The parameter value set by this method is stored internally and
2082+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
2083+ * object's command when the method <code>execute</code> is called.
2084+ * Methods such as <code>execute</code> and <code>populate</code> must be
2085+ * provided in any class that extends this class and implements one or
2086+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
2087+ * <P>
2088+ * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2089+ * as it is undefined in this class.
2090+ * <P>
2091+ * Calls made to the method <code>getParams</code> after this version of
2092+ * <code>setTimestamp</code>
2093+ * has been called will return an array with the value for parameter placeholder
2094+ * number <i>parameterIndex</i> being the <code>Timestamp</code> object that was
2095+ * supplied as the second parameter to this method.
2096+ * Note that because the numbering of elements in an array starts at zero,
2097+ * the array element that corresponds to placeholder parameter number
2098+ * <i>parameterIndex</i> is <i>parameterIndex</i> -1.
2099+ *
2100+ * @param parameterIndex the ordinal number of the placeholder parameter
2101+ * in this <code>RowSet</code> object's command that is to be set.
2102+ * The first parameter is 1, the second is 2, and so on; must be
2103+ * <code>1</code> or greater
2104+ * @param x a <code>java.sql.Timestamp</code> object
2105+ * @throws SQLException if an error occurs or the
2106+ * parameter index is out of bounds
2107+ * @see #getParams
2108+ */
2109+ public void setTimestamp(int parameterIndex, java.sql.Timestamp x) throws SQLException {
2110+ checkParamIndex(parameterIndex);
2111+ if(params == null){
2112+ throw new SQLException("Set initParams() before setTimestamp");
2113+ }
2114+
2115+ params.put(Integer.valueOf(parameterIndex - 1), x);
2116+ }
2117+
2118+ /**
2119+ * Sets the designated parameter to the given
2120+ * <code>java.io.InputStream</code> object,
2121+ * which will have the specified number of bytes.
2122+ * The contents of the stream will be read and sent to the database.
2123+ * This method throws an <code>SQLException</code> object if the number of bytes
2124+ * read and sent to the database is not equal to <i>length</i>.
2125+ * <P>
2126+ * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
2127+ * parameter, it may be more practical to send it via a
2128+ * <code>java.io.InputStream</code> object. A JDBC technology-enabled
2129+ * driver will read the data from the stream as needed until it reaches
2130+ * end-of-file. The driver will do any necessary conversion from ASCII to
2131+ * the database <code>CHAR</code> format.
2132+ *
2133+ * <P><B>Note:</B> This stream object can be either a standard
2134+ * Java stream object or your own subclass that implements the
2135+ * standard interface.
2136+ * <P>
2137+ * The parameter value set by this method is stored internally and
2138+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
2139+ * object's command when the method <code>execute</code> is called.
2140+ * Methods such as <code>execute</code> and <code>populate</code> must be
2141+ * provided in any class that extends this class and implements one or
2142+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
2143+ * <P>
2144+ * Note: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2145+ * as it is undefined in this class.
2146+ * <P>
2147+ * Calls made to the method <code>getParams</code> after <code>setAsciiStream</code>
2148+ * has been called will return an array containing the parameter values that
2149+ * have been set. The element in the array that represents the values
2150+ * set with this method will itself be an array. The first element of that array
2151+ * is the given <code>java.io.InputStream</code> object.
2152+ * The second element is the value set for <i>length</i>.
2153+ * The third element is an internal <code>BaseRowSet</code> constant
2154+ * specifying that the stream passed to this method is an ASCII stream.
2155+ * The parameter number is indicated by an element's position in the array
2156+ * returned by the method <code>getParams</code>,
2157+ * with the first element being the value for the first placeholder parameter, the
2158+ * second element being the value for the second placeholder parameter, and so on.
2159+ * In other words, if the input stream being set is the value for the second
2160+ * placeholder parameter, the array containing it will be the second element in
2161+ * the array returned by <code>getParams</code>.
2162+ * <P>
2163+ * Note that because the numbering of elements in an array starts at zero,
2164+ * the array element that corresponds to placeholder parameter number
2165+ * <i>parameterIndex</i> is element number <i>parameterIndex</i> -1.
2166+ *
2167+ * @param parameterIndex the ordinal number of the placeholder parameter
2168+ * in this <code>RowSet</code> object's command that is to be set.
2169+ * The first parameter is 1, the second is 2, and so on; must be
2170+ * <code>1</code> or greater
2171+ * @param x the Java input stream that contains the ASCII parameter value
2172+ * @param length the number of bytes in the stream. This is the number of bytes
2173+ * the driver will send to the DBMS; lengths of 0 or less are
2174+ * are undefined but will cause an invalid length exception to be
2175+ * thrown in the underlying JDBC driver.
2176+ * @throws SQLException if an error occurs, the parameter index is out of bounds,
2177+ * or when connected to a data source, the number of bytes the driver reads
2178+ * and sends to the database is not equal to the number of bytes specified
2179+ * in <i>length</i>
2180+ * @see #getParams
2181+ */
2182+ public void setAsciiStream(int parameterIndex, java.io.InputStream x, int length) throws SQLException {
2183+ Object asciiStream[];
2184+ checkParamIndex(parameterIndex);
2185+
2186+ asciiStream = new Object[3];
2187+ asciiStream[0] = x;
2188+ asciiStream[1] = Integer.valueOf(length);
2189+ asciiStream[2] = Integer.valueOf(ASCII_STREAM_PARAM);
2190+
2191+ if(params == null){
2192+ throw new SQLException("Set initParams() before setAsciiStream");
2193+ }
2194+
2195+ params.put(Integer.valueOf(parameterIndex - 1), asciiStream);
2196+ }
2197+
2198+ /**
2199+ * Sets the designated parameter in this <code>RowSet</code> object's command
2200+ * to the given input stream.
2201+ * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
2202+ * parameter, it may be more practical to send it via a
2203+ * <code>java.io.InputStream</code>. Data will be read from the stream
2204+ * as needed until end-of-file is reached. The JDBC driver will
2205+ * do any necessary conversion from ASCII to the database char format.
2206+ *
2207+ * <P><B>Note:</B> This stream object can either be a standard
2208+ * Java stream object or your own subclass that implements the
2209+ * standard interface.
2210+ * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
2211+ * it might be more efficient to use a version of
2212+ * <code>setAsciiStream</code> which takes a length parameter.
2213+ *
2214+ * @param parameterIndex the first parameter is 1, the second is 2, ...
2215+ * @param x the Java input stream that contains the ASCII parameter value
2216+ * @exception SQLException if a database access error occurs or
2217+ * this method is called on a closed <code>PreparedStatement</code>
2218+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
2219+ * @since 1.6
2220+ */
2221+ public void setAsciiStream(int parameterIndex, java.io.InputStream x)
2222+ throws SQLException {
2223+ throw new SQLFeatureNotSupportedException("Feature not supported");
2224+ }
2225+
2226+ /**
2227+ * Sets the designated parameter to the given <code>java.io.InputStream</code>
2228+ * object, which will have the specified number of bytes.
2229+ * The contents of the stream will be read and sent to the database.
2230+ * This method throws an <code>SQLException</code> object if the number of bytes
2231+ * read and sent to the database is not equal to <i>length</i>.
2232+ * <P>
2233+ * When a very large binary value is input to a
2234+ * <code>LONGVARBINARY</code> parameter, it may be more practical
2235+ * to send it via a <code>java.io.InputStream</code> object.
2236+ * A JDBC technology-enabled driver will read the data from the
2237+ * stream as needed until it reaches end-of-file.
2238+ *
2239+ * <P><B>Note:</B> This stream object can be either a standard
2240+ * Java stream object or your own subclass that implements the
2241+ * standard interface.
2242+ * <P>
2243+ * The parameter value set by this method is stored internally and
2244+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
2245+ * object's command when the method <code>execute</code> is called.
2246+ * Methods such as <code>execute</code> and <code>populate</code> must be
2247+ * provided in any class that extends this class and implements one or
2248+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
2249+ *<P>
2250+ * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2251+ * as it is undefined in this class.
2252+ * <P>
2253+ * Calls made to the method <code>getParams</code> after <code>setBinaryStream</code>
2254+ * has been called will return an array containing the parameter values that
2255+ * have been set. In that array, the element that represents the values
2256+ * set with this method will itself be an array. The first element of that array
2257+ * is the given <code>java.io.InputStream</code> object.
2258+ * The second element is the value set for <i>length</i>.
2259+ * The third element is an internal <code>BaseRowSet</code> constant
2260+ * specifying that the stream passed to this method is a binary stream.
2261+ * The parameter number is indicated by an element's position in the array
2262+ * returned by the method <code>getParams</code>,
2263+ * with the first element being the value for the first placeholder parameter, the
2264+ * second element being the value for the second placeholder parameter, and so on.
2265+ * In other words, if the input stream being set is the value for the second
2266+ * placeholder parameter, the array containing it will be the second element in
2267+ * the array returned by <code>getParams</code>.
2268+ * <P>
2269+ * Note that because the numbering of elements in an array starts at zero,
2270+ * the array element that corresponds to placeholder parameter number
2271+ * <i>parameterIndex</i> is element number <i>parameterIndex</i> -1.
2272+ *
2273+ * @param parameterIndex the ordinal number of the placeholder parameter
2274+ * in this <code>RowSet</code> object's command that is to be set.
2275+ * The first parameter is 1, the second is 2, and so on; must be
2276+ * <code>1</code> or greater
2277+ * @param x the input stream that contains the binary value to be set
2278+ * @param length the number of bytes in the stream; lengths of 0 or less are
2279+ * are undefined but will cause an invalid length exception to be
2280+ * thrown in the underlying JDBC driver.
2281+ * @throws SQLException if an error occurs, the parameter index is out of bounds,
2282+ * or when connected to a data source, the number of bytes the driver
2283+ * reads and sends to the database is not equal to the number of bytes
2284+ * specified in <i>length</i>
2285+ * @see #getParams
2286+ */
2287+ public void setBinaryStream(int parameterIndex, java.io.InputStream x, int length) throws SQLException {
2288+ Object binaryStream[];
2289+ checkParamIndex(parameterIndex);
2290+
2291+ binaryStream = new Object[3];
2292+ binaryStream[0] = x;
2293+ binaryStream[1] = Integer.valueOf(length);
2294+ binaryStream[2] = Integer.valueOf(BINARY_STREAM_PARAM);
2295+ if(params == null){
2296+ throw new SQLException("Set initParams() before setBinaryStream");
2297+ }
2298+
2299+ params.put(Integer.valueOf(parameterIndex - 1), binaryStream);
2300+ }
2301+
2302+
2303+ /**
2304+ * Sets the designated parameter in this <code>RowSet</code> object's command
2305+ * to the given input stream.
2306+ * When a very large binary value is input to a <code>LONGVARBINARY</code>
2307+ * parameter, it may be more practical to send it via a
2308+ * <code>java.io.InputStream</code> object. The data will be read from the
2309+ * stream as needed until end-of-file is reached.
2310+ *
2311+ * <P><B>Note:</B> This stream object can either be a standard
2312+ * Java stream object or your own subclass that implements the
2313+ * standard interface.
2314+ * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
2315+ * it might be more efficient to use a version of
2316+ * <code>setBinaryStream</code> which takes a length parameter.
2317+ *
2318+ * @param parameterIndex the first parameter is 1, the second is 2, ...
2319+ * @param x the java input stream which contains the binary parameter value
2320+ * @exception SQLException if a database access error occurs or
2321+ * this method is called on a closed <code>PreparedStatement</code>
2322+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
2323+ * @since 1.6
2324+ */
2325+ public void setBinaryStream(int parameterIndex, java.io.InputStream x)
2326+ throws SQLException {
2327+ throw new SQLFeatureNotSupportedException("Feature not supported");
2328+ }
2329+
2330+
2331+ /**
2332+ * Sets the designated parameter to the given
2333+ * <code>java.io.InputStream</code> object, which will have the specified
2334+ * number of bytes. The contents of the stream will be read and sent
2335+ * to the database.
2336+ * This method throws an <code>SQLException</code> if the number of bytes
2337+ * read and sent to the database is not equal to <i>length</i>.
2338+ * <P>
2339+ * When a very large Unicode value is input to a
2340+ * <code>LONGVARCHAR</code> parameter, it may be more practical
2341+ * to send it via a <code>java.io.InputStream</code> object.
2342+ * A JDBC technology-enabled driver will read the data from the
2343+ * stream as needed, until it reaches end-of-file.
2344+ * The driver will do any necessary conversion from Unicode to the
2345+ * database <code>CHAR</code> format.
2346+ * The byte format of the Unicode stream must be Java UTF-8, as
2347+ * defined in the Java Virtual Machine Specification.
2348+ *
2349+ * <P><B>Note:</B> This stream object can be either a standard
2350+ * Java stream object or your own subclass that implements the
2351+ * standard interface.
2352+ * <P>
2353+ * This method is deprecated; the method <code>getCharacterStream</code>
2354+ * should be used in its place.
2355+ * <P>
2356+ * The parameter value set by this method is stored internally and
2357+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
2358+ * object's command when the method <code>execute</code> is called.
2359+ * Calls made to the method <code>getParams</code> after <code>setUnicodeStream</code>
2360+ * has been called will return an array containing the parameter values that
2361+ * have been set. In that array, the element that represents the values
2362+ * set with this method will itself be an array. The first element of that array
2363+ * is the given <code>java.io.InputStream</code> object.
2364+ * The second element is the value set for <i>length</i>.
2365+ * The third element is an internal <code>BaseRowSet</code> constant
2366+ * specifying that the stream passed to this method is a Unicode stream.
2367+ * The parameter number is indicated by an element's position in the array
2368+ * returned by the method <code>getParams</code>,
2369+ * with the first element being the value for the first placeholder parameter, the
2370+ * second element being the value for the second placeholder parameter, and so on.
2371+ * In other words, if the input stream being set is the value for the second
2372+ * placeholder parameter, the array containing it will be the second element in
2373+ * the array returned by <code>getParams</code>.
2374+ * <P>
2375+ * Note that because the numbering of elements in an array starts at zero,
2376+ * the array element that corresponds to placeholder parameter number
2377+ * <i>parameterIndex</i> is element number <i>parameterIndex</i> -1.
2378+ *
2379+ * @param parameterIndex the ordinal number of the placeholder parameter
2380+ * in this <code>RowSet</code> object's command that is to be set.
2381+ * The first parameter is 1, the second is 2, and so on; must be
2382+ * <code>1</code> or greater
2383+ * @param x the <code>java.io.InputStream</code> object that contains the
2384+ * UNICODE parameter value
2385+ * @param length the number of bytes in the input stream
2386+ * @throws SQLException if an error occurs, the parameter index is out of bounds,
2387+ * or the number of bytes the driver reads and sends to the database is
2388+ * not equal to the number of bytes specified in <i>length</i>
2389+ * @deprecated getCharacterStream should be used in its place
2390+ * @see #getParams
2391+ */
2392+
2393+ public void setUnicodeStream(int parameterIndex, java.io.InputStream x, int length) throws SQLException {
2394+ Object unicodeStream[];
2395+ checkParamIndex(parameterIndex);
2396+
2397+ unicodeStream = new Object[3];
2398+ unicodeStream[0] = x;
2399+ unicodeStream[1] = Integer.valueOf(length);
2400+ unicodeStream[2] = Integer.valueOf(UNICODE_STREAM_PARAM);
2401+ if(params == null){
2402+ throw new SQLException("Set initParams() before setUnicodeStream");
2403+ }
2404+ params.put(Integer.valueOf(parameterIndex - 1), unicodeStream);
2405+ }
2406+
2407+ /**
2408+ * Sets the designated parameter to the given <code>java.io.Reader</code>
2409+ * object, which will have the specified number of characters. The
2410+ * contents of the reader will be read and sent to the database.
2411+ * This method throws an <code>SQLException</code> if the number of bytes
2412+ * read and sent to the database is not equal to <i>length</i>.
2413+ * <P>
2414+ * When a very large Unicode value is input to a
2415+ * <code>LONGVARCHAR</code> parameter, it may be more practical
2416+ * to send it via a <code>Reader</code> object.
2417+ * A JDBC technology-enabled driver will read the data from the
2418+ * stream as needed until it reaches end-of-file.
2419+ * The driver will do any necessary conversion from Unicode to the
2420+ * database <code>CHAR</code> format.
2421+ * The byte format of the Unicode stream must be Java UTF-8, as
2422+ * defined in the Java Virtual Machine Specification.
2423+ *
2424+ * <P><B>Note:</B> This stream object can be either a standard
2425+ * Java stream object or your own subclass that implements the
2426+ * standard interface.
2427+ * <P>
2428+ * The parameter value set by this method is stored internally and
2429+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
2430+ * object's command when the method <code>execute</code> is called.
2431+ * Methods such as <code>execute</code> and <code>populate</code> must be
2432+ * provided in any class that extends this class and implements one or
2433+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
2434+ * <P>
2435+ * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2436+ * as it is undefined in this class.
2437+ * <P>
2438+ * Calls made to the method <code>getParams</code> after
2439+ * <code>setCharacterStream</code>
2440+ * has been called will return an array containing the parameter values that
2441+ * have been set. In that array, the element that represents the values
2442+ * set with this method will itself be an array. The first element of that array
2443+ * is the given <code>java.io.Reader</code> object.
2444+ * The second element is the value set for <i>length</i>.
2445+ * The parameter number is indicated by an element's position in the array
2446+ * returned by the method <code>getParams</code>,
2447+ * with the first element being the value for the first placeholder parameter, the
2448+ * second element being the value for the second placeholder parameter, and so on.
2449+ * In other words, if the reader being set is the value for the second
2450+ * placeholder parameter, the array containing it will be the second element in
2451+ * the array returned by <code>getParams</code>.
2452+ * <P>
2453+ * Note that because the numbering of elements in an array starts at zero,
2454+ * the array element that corresponds to placeholder parameter number
2455+ * <i>parameterIndex</i> is element number <i>parameterIndex</i> -1.
2456+ *
2457+ * @param parameterIndex the ordinal number of the placeholder parameter
2458+ * in this <code>RowSet</code> object's command that is to be set.
2459+ * The first parameter is 1, the second is 2, and so on; must be
2460+ * <code>1</code> or greater
2461+ * @param reader the <code>Reader</code> object that contains the
2462+ * Unicode data
2463+ * @param length the number of characters in the stream; lengths of 0 or
2464+ * less are undefined but will cause an invalid length exception to
2465+ * be thrown in the underlying JDBC driver.
2466+ * @throws SQLException if an error occurs, the parameter index is out of bounds,
2467+ * or when connected to a data source, the number of bytes the driver
2468+ * reads and sends to the database is not equal to the number of bytes
2469+ * specified in <i>length</i>
2470+ * @see #getParams
2471+ */
2472+ public void setCharacterStream(int parameterIndex, Reader reader, int length) throws SQLException {
2473+ Object charStream[];
2474+ checkParamIndex(parameterIndex);
2475+
2476+ charStream = new Object[2];
2477+ charStream[0] = reader;
2478+ charStream[1] = Integer.valueOf(length);
2479+ if(params == null){
2480+ throw new SQLException("Set initParams() before setCharacterStream");
2481+ }
2482+ params.put(Integer.valueOf(parameterIndex - 1), charStream);
2483+ }
2484+
2485+ /**
2486+ * Sets the designated parameter in this <code>RowSet</code> object's command
2487+ * to the given <code>Reader</code>
2488+ * object.
2489+ * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
2490+ * parameter, it may be more practical to send it via a
2491+ * <code>java.io.Reader</code> object. The data will be read from the stream
2492+ * as needed until end-of-file is reached. The JDBC driver will
2493+ * do any necessary conversion from UNICODE to the database char format.
2494+ *
2495+ * <P><B>Note:</B> This stream object can either be a standard
2496+ * Java stream object or your own subclass that implements the
2497+ * standard interface.
2498+ * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
2499+ * it might be more efficient to use a version of
2500+ * <code>setCharacterStream</code> which takes a length parameter.
2501+ *
2502+ * @param parameterIndex the first parameter is 1, the second is 2, ...
2503+ * @param reader the <code>java.io.Reader</code> object that contains the
2504+ * Unicode data
2505+ * @exception SQLException if a database access error occurs or
2506+ * this method is called on a closed <code>PreparedStatement</code>
2507+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
2508+ * @since 1.6
2509+ */
2510+ public void setCharacterStream(int parameterIndex,
2511+ java.io.Reader reader) throws SQLException {
2512+ throw new SQLFeatureNotSupportedException("Feature not supported");
2513+ }
2514+
2515+ /**
2516+ * Sets the designated parameter to an <code>Object</code> in the Java
2517+ * programming language. The second parameter must be an
2518+ * <code>Object</code> type. For integral values, the
2519+ * <code>java.lang</code> equivalent
2520+ * objects should be used. For example, use the class <code>Integer</code>
2521+ * for an <code>int</code>.
2522+ * <P>
2523+ * The driver converts this object to the specified
2524+ * target SQL type before sending it to the database.
2525+ * If the object has a custom mapping (is of a class implementing
2526+ * <code>SQLData</code>), the driver should call the method
2527+ * <code>SQLData.writeSQL</code> to write the object to the SQL
2528+ * data stream. If, on the other hand, the object is of a class
2529+ * implementing <code>Ref</code>, <code>Blob</code>, <code>Clob</code>,
2530+ * <code>Struct</code>, or <code>Array</code>,
2531+ * the driver should pass it to the database as a value of the
2532+ * corresponding SQL type.
2533+ * <P>
2534+ * <p>Note that this method may be used to pass database-
2535+ * specific abstract data types.
2536+ * <P>
2537+ * The parameter value set by this method is stored internally and
2538+ * will be supplied as the appropriate parameter in this <code>RowSet</code
2539+ * object's command when the method <code>execute</code> is called.
2540+ * Methods such as <code>execute</code> and <code>populate</code> must be
2541+ * provided in any class that extends this class and implements one or
2542+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
2543+ * <P>
2544+ * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2545+ * as it is undefined in this class.
2546+ * <P>
2547+ * Calls made to the method <code>getParams</code> after this version of
2548+ * <code>setObject</code>
2549+ * has been called will return an array containing the parameter values that
2550+ * have been set. In that array, the element that represents the values
2551+ * set with this method will itself be an array. The first element of that array
2552+ * is the given <code>Object</code> instance, and the
2553+ * second element is the value set for <i>targetSqlType</i>. The
2554+ * third element is the value set for <i>scale</i>, which the driver will
2555+ * ignore if the type of the object being set is not
2556+ * <code>java.sql.Types.NUMERIC</code> or <code>java.sql.Types.DECIMAL</code>.
2557+ * The parameter number is indicated by an element's position in the array
2558+ * returned by the method <code>getParams</code>,
2559+ * with the first element being the value for the first placeholder parameter, the
2560+ * second element being the value for the second placeholder parameter, and so on.
2561+ * In other words, if the object being set is the value for the second
2562+ * placeholder parameter, the array containing it will be the second element in
2563+ * the array returned by <code>getParams</code>.
2564+ *<P>
2565+ * Note that because the numbering of elements in an array starts at zero,
2566+ * the array element that corresponds to placeholder parameter number
2567+ * <i>parameterIndex</i> is element number <i>parameterIndex</i> -1.
2568+ *
2569+ *
2570+ * @param parameterIndex the ordinal number of the placeholder parameter
2571+ * in this <code>RowSet</code> object's command that is to be set.
2572+ * The first parameter is 1, the second is 2, and so on; must be
2573+ * <code>1</code> or greater
2574+ * @param x the <code>Object</code> containing the input parameter value;
2575+ * must be an <code>Object</code> type
2576+ * @param targetSqlType the SQL type (as defined in <code>java.sql.Types</code>)
2577+ * to be sent to the database. The <code>scale</code> argument may
2578+ * further qualify this type. If a non-standard <i>targetSqlType</i>
2579+ * is supplied, this method will not throw a <code>SQLException</code>.
2580+ * This allows implicit support for non-standard SQL types.
2581+ * @param scale for the types <code>java.sql.Types.DECIMAL</code> and
2582+ * <code>java.sql.Types.NUMERIC</code>, this is the number
2583+ * of digits after the decimal point. For all other types, this
2584+ * value will be ignored.
2585+ * @throws SQLException if an error occurs or the parameter index is out of bounds
2586+ * @see #getParams
2587+ */
2588+ public void setObject(int parameterIndex, Object x, int targetSqlType, int scale) throws SQLException {
2589+ Object obj[];
2590+ checkParamIndex(parameterIndex);
2591+
2592+ obj = new Object[3];
2593+ obj[0] = x;
2594+ obj[1] = Integer.valueOf(targetSqlType);
2595+ obj[2] = Integer.valueOf(scale);
2596+ if(params == null){
2597+ throw new SQLException("Set initParams() before setObject");
2598+ }
2599+ params.put(Integer.valueOf(parameterIndex - 1), obj);
2600+ }
2601+
2602+ /**
2603+ * Sets the value of the designated parameter with the given
2604+ * <code>Object</code> value.
2605+ * This method is like <code>setObject(int parameterIndex, Object x, int
2606+ * targetSqlType, int scale)</code> except that it assumes a scale of zero.
2607+ * <P>
2608+ * The parameter value set by this method is stored internally and
2609+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
2610+ * object's command when the method <code>execute</code> is called.
2611+ * Methods such as <code>execute</code> and <code>populate</code> must be
2612+ * provided in any class that extends this class and implements one or
2613+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
2614+ * <P>
2615+ * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2616+ * as it is undefined in this class.
2617+ * <P>
2618+ * Calls made to the method <code>getParams</code> after this version of
2619+ * <code>setObject</code>
2620+ * has been called will return an array containing the parameter values that
2621+ * have been set. In that array, the element that represents the values
2622+ * set with this method will itself be an array. The first element of that array
2623+ * is the given <code>Object</code> instance.
2624+ * The second element is the value set for <i>targetSqlType</i>.
2625+ * The parameter number is indicated by an element's position in the array
2626+ * returned by the method <code>getParams</code>,
2627+ * with the first element being the value for the first placeholder parameter, the
2628+ * second element being the value for the second placeholder parameter, and so on.
2629+ * In other words, if the object being set is the value for the second
2630+ * placeholder parameter, the array containing it will be the second element in
2631+ * the array returned by <code>getParams</code>.
2632+ * <P>
2633+ * Note that because the numbering of elements in an array starts at zero,
2634+ * the array element that corresponds to placeholder parameter number
2635+ * <i>parameterIndex</i> is element number <i>parameterIndex</i> -1.
2636+ *
2637+ * @param parameterIndex the ordinal number of the placeholder parameter
2638+ * in this <code>RowSet</code> object's command that is to be set.
2639+ * The first parameter is 1, the second is 2, and so on; must be
2640+ * <code>1</code> or greater
2641+ * @param x the <code>Object</code> containing the input parameter value;
2642+ * must be an <code>Object</code> type
2643+ * @param targetSqlType the SQL type (as defined in <code>java.sql.Types</code>)
2644+ * to be sent to the database. If a non-standard <i>targetSqlType</i>
2645+ * is supplied, this method will not throw a <code>SQLException</code>.
2646+ * This allows implicit support for non-standard SQL types.
2647+ * @throws SQLException if an error occurs or the parameter index
2648+ * is out of bounds
2649+ * @see #getParams
2650+ */
2651+ public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
2652+ Object obj[];
2653+ checkParamIndex(parameterIndex);
2654+
2655+ obj = new Object[2];
2656+ obj[0] = x;
2657+ obj[1] = Integer.valueOf(targetSqlType);
2658+ if (params == null){
2659+ throw new SQLException("Set initParams() before setObject");
2660+ }
2661+ params.put(Integer.valueOf(parameterIndex - 1), obj);
2662+ }
2663+
2664+ /**
2665+ * Sets the designated parameter to an <code>Object</code> in the Java
2666+ * programming language. The second parameter must be an
2667+ * <code>Object</code>
2668+ * type. For integral values, the <code>java.lang</code> equivalent
2669+ * objects should be used. For example, use the class <code>Integer</code>
2670+ * for an <code>int</code>.
2671+ * <P>
2672+ * The JDBC specification defines a standard mapping from
2673+ * Java <code>Object</code> types to SQL types. The driver will
2674+ * use this standard mapping to convert the given object
2675+ * to its corresponding SQL type before sending it to the database.
2676+ * If the object has a custom mapping (is of a class implementing
2677+ * <code>SQLData</code>), the driver should call the method
2678+ * <code>SQLData.writeSQL</code> to write the object to the SQL
2679+ * data stream.
2680+ * <P>
2681+ * If, on the other hand, the object is of a class
2682+ * implementing <code>Ref</code>, <code>Blob</code>, <code>Clob</code>,
2683+ * <code>Struct</code>, or <code>Array</code>,
2684+ * the driver should pass it to the database as a value of the
2685+ * corresponding SQL type.
2686+ * <P>
2687+ * This method throws an exception if there
2688+ * is an ambiguity, for example, if the object is of a class
2689+ * implementing more than one interface.
2690+ * <P>
2691+ * Note that this method may be used to pass database-specific
2692+ * abstract data types.
2693+ * <P>
2694+ * The parameter value set by this method is stored internally and
2695+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
2696+ * object's command when the method <code>execute</code> is called.
2697+ * Methods such as <code>execute</code> and <code>populate</code> must be
2698+ * provided in any class that extends this class and implements one or
2699+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
2700+ * <p>
2701+ * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2702+ * as it is undefined in this class.
2703+ * <P>
2704+ * After this method has been called, a call to the
2705+ * method <code>getParams</code>
2706+ * will return an object array of the current command parameters, which will
2707+ * include the <code>Object</code> set for placeholder parameter number
2708+ * <code>parameterIndex</code>.
2709+ * Note that because the numbering of elements in an array starts at zero,
2710+ * the array element that corresponds to placeholder parameter number
2711+ * <i>parameterIndex</i> is element number <i>parameterIndex</i> -1.
2712+ *
2713+ * @param parameterIndex the ordinal number of the placeholder parameter
2714+ * in this <code>RowSet</code> object's command that is to be set.
2715+ * The first parameter is 1, the second is 2, and so on; must be
2716+ * <code>1</code> or greater
2717+ * @param x the object containing the input parameter value
2718+ * @throws SQLException if an error occurs the
2719+ * parameter index is out of bounds, or there
2720+ * is ambiguity in the implementation of the
2721+ * object being set
2722+ * @see #getParams
2723+ */
2724+ public void setObject(int parameterIndex, Object x) throws SQLException {
2725+ checkParamIndex(parameterIndex);
2726+ if (params == null) {
2727+ throw new SQLException("Set initParams() before setObject");
2728+ }
2729+ params.put(Integer.valueOf(parameterIndex - 1), x);
2730+ }
2731+
2732+ /**
2733+ * Sets the designated parameter to the given <code>Ref</code> object in
2734+ * the Java programming language. The driver converts this to an SQL
2735+ * <code>REF</code> value when it sends it to the database. Internally, the
2736+ * <code>Ref</code> is represented as a <code>SerialRef</code> to ensure
2737+ * serializability.
2738+ * <P>
2739+ * The parameter value set by this method is stored internally and
2740+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
2741+ * object's command when the method <code>execute</code> is called.
2742+ * Methods such as <code>execute</code> and <code>populate</code> must be
2743+ * provided in any class that extends this class and implements one or
2744+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
2745+ * <p>
2746+ * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2747+ * as it is undefined in this class.
2748+ * <p>
2749+ * After this method has been called, a call to the
2750+ * method <code>getParams</code>
2751+ * will return an object array of the current command parameters, which will
2752+ * include the <code>Ref</code> object set for placeholder parameter number
2753+ * <code>parameterIndex</code>.
2754+ * Note that because the numbering of elements in an array starts at zero,
2755+ * the array element that corresponds to placeholder parameter number
2756+ * <i>parameterIndex</i> is element number <i>parameterIndex</i> -1.
2757+ *
2758+ * @param parameterIndex the ordinal number of the placeholder parameter
2759+ * in this <code>RowSet</code> object's command that is to be set.
2760+ * The first parameter is 1, the second is 2, and so on; must be
2761+ * <code>1</code> or greater
2762+ * @param ref a <code>Ref</code> object representing an SQL <code>REF</code>
2763+ * value; cannot be null
2764+ * @throws SQLException if an error occurs; the parameter index is out of
2765+ * bounds or the <code>Ref</code> object is <code>null</code>; or
2766+ * the <code>Ref</code> object returns a <code>null</code> base type
2767+ * name.
2768+ * @see #getParams
2769+ * @see javax.sql.rowset.serial.SerialRef
2770+ */
2771+ public void setRef (int parameterIndex, Ref ref) throws SQLException {
2772+ checkParamIndex(parameterIndex);
2773+ if (params == null) {
2774+ throw new SQLException("Set initParams() before setRef");
2775+ }
2776+ params.put(Integer.valueOf(parameterIndex - 1), new SerialRef(ref));
2777+ }
2778+
2779+ /**
2780+ * Sets the designated parameter to the given <code>Blob</code> object in
2781+ * the Java programming language. The driver converts this to an SQL
2782+ * <code>BLOB</code> value when it sends it to the database. Internally,
2783+ * the <code>Blob</code> is represented as a <code>SerialBlob</code>
2784+ * to ensure serializability.
2785+ * <P>
2786+ * The parameter value set by this method is stored internally and
2787+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
2788+ * object's command when the method <code>execute</code> is called.
2789+ * Methods such as <code>execute</code> and <code>populate</code> must be
2790+ * provided in any class that extends this class and implements one or
2791+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
2792+ * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2793+ * as it is undefined in this class.
2794+ * <p>
2795+ * After this method has been called, a call to the
2796+ * method <code>getParams</code>
2797+ * will return an object array of the current command parameters, which will
2798+ * include the <code>Blob</code> object set for placeholder parameter number
2799+ * <code>parameterIndex</code>.
2800+ * Note that because the numbering of elements in an array starts at zero,
2801+ * the array element that corresponds to placeholder parameter number
2802+ * <i>parameterIndex</i> is element number <i>parameterIndex</i> -1.
2803+ *
2804+ * @param parameterIndex the ordinal number of the placeholder parameter
2805+ * in this <code>RowSet</code> object's command that is to be set.
2806+ * The first parameter is 1, the second is 2, and so on; must be
2807+ * <code>1</code> or greater
2808+ * @param x a <code>Blob</code> object representing an SQL
2809+ * <code>BLOB</code> value
2810+ * @throws SQLException if an error occurs or the
2811+ * parameter index is out of bounds
2812+ * @see #getParams
2813+ * @see javax.sql.rowset.serial.SerialBlob
2814+ */
2815+ public void setBlob (int parameterIndex, Blob x) throws SQLException {
2816+ checkParamIndex(parameterIndex);
2817+ if(params == null){
2818+ throw new SQLException("Set initParams() before setBlob");
2819+ }
2820+ params.put(Integer.valueOf(parameterIndex - 1), new SerialBlob(x));
2821+ }
2822+
2823+ /**
2824+ * Sets the designated parameter to the given <code>Clob</code> object in
2825+ * the Java programming language. The driver converts this to an SQL
2826+ * <code>CLOB</code> value when it sends it to the database. Internally, the
2827+ * <code>Clob</code> is represented as a <code>SerialClob</code> to ensure
2828+ * serializability.
2829+ * <P>
2830+ * The parameter value set by this method is stored internally and
2831+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
2832+ * object's command when the method <code>execute</code> is called.
2833+ * Methods such as <code>execute</code> and <code>populate</code> must be
2834+ * provided in any class that extends this class and implements one or
2835+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
2836+ * <p>
2837+ * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2838+ * as it is undefined in this class.
2839+ * <p>
2840+ * After this method has been called, a call to the
2841+ * method <code>getParams</code>
2842+ * will return an object array of the current command parameters, which will
2843+ * include the <code>Clob</code> object set for placeholder parameter number
2844+ * <code>parameterIndex</code>.
2845+ * Note that because the numbering of elements in an array starts at zero,
2846+ * the array element that corresponds to placeholder parameter number
2847+ * <i>parameterIndex</i> is element number <i>parameterIndex</i> -1.
2848+ *
2849+ * @param parameterIndex the ordinal number of the placeholder parameter
2850+ * in this <code>RowSet</code> object's command that is to be set.
2851+ * The first parameter is 1, the second is 2, and so on; must be
2852+ * <code>1</code> or greater
2853+ * @param x a <code>Clob</code> object representing an SQL
2854+ * <code>CLOB</code> value; cannot be null
2855+ * @throws SQLException if an error occurs; the parameter index is out of
2856+ * bounds or the <code>Clob</code> is null
2857+ * @see #getParams
2858+ * @see javax.sql.rowset.serial.SerialBlob
2859+ */
2860+ public void setClob (int parameterIndex, Clob x) throws SQLException {
2861+ checkParamIndex(parameterIndex);
2862+ if(params == null){
2863+ throw new SQLException("Set initParams() before setClob");
2864+ }
2865+ params.put(Integer.valueOf(parameterIndex - 1), new SerialClob(x));
2866+ }
2867+
2868+ /**
2869+ * Sets the designated parameter to an <code>Array</code> object in the
2870+ * Java programming language. The driver converts this to an SQL
2871+ * <code>ARRAY</code> value when it sends it to the database. Internally,
2872+ * the <code>Array</code> is represented as a <code>SerialArray</code>
2873+ * to ensure serializability.
2874+ * <P>
2875+ * The parameter value set by this method is stored internally and
2876+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
2877+ * object's command when the method <code>execute</code> is called.
2878+ * Methods such as <code>execute</code> and <code>populate</code> must be
2879+ * provided in any class that extends this class and implements one or
2880+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
2881+ * <P>
2882+ * Note: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2883+ * as it is undefined in this class.
2884+ * <p>
2885+ * After this method has been called, a call to the
2886+ * method <code>getParams</code>
2887+ * will return an object array of the current command parameters, which will
2888+ * include the <code>Array</code> object set for placeholder parameter number
2889+ * <code>parameterIndex</code>.
2890+ * Note that because the numbering of elements in an array starts at zero,
2891+ * the array element that corresponds to placeholder parameter number
2892+ * <i>parameterIndex</i> is element number <i>parameterIndex</i> -1.
2893+ *
2894+ * @param parameterIndex the ordinal number of the placeholder parameter
2895+ * in this <code>RowSet</code> object's command that is to be set.
2896+ * The first parameter is 1, the second is 2, and so on; must be
2897+ * <code>1</code> or greater
2898+ * @param array an <code>Array</code> object representing an SQL
2899+ * <code>ARRAY</code> value; cannot be null. The <code>Array</code> object
2900+ * passed to this method must return a non-null Object for all
2901+ * <code>getArray()</code> method calls. A null value will cause a
2902+ * <code>SQLException</code> to be thrown.
2903+ * @throws SQLException if an error occurs; the parameter index is out of
2904+ * bounds or the <code>ARRAY</code> is null
2905+ * @see #getParams
2906+ * @see javax.sql.rowset.serial.SerialArray
2907+ */
2908+ public void setArray (int parameterIndex, Array array) throws SQLException {
2909+ checkParamIndex(parameterIndex);
2910+ if (params == null){
2911+ throw new SQLException("Set initParams() before setArray");
2912+ }
2913+ params.put(Integer.valueOf(parameterIndex - 1), new SerialArray(array));
2914+ }
2915+
2916+ /**
2917+ * Sets the designated parameter to the given <code>java.sql.Date</code>
2918+ * object.
2919+ * When the DBMS does not store time zone information, the driver will use
2920+ * the given <code>Calendar</code> object to construct the SQL <code>DATE</code>
2921+ * value to send to the database. With a
2922+ * <code>Calendar</code> object, the driver can calculate the date
2923+ * taking into account a custom time zone. If no <code>Calendar</code>
2924+ * object is specified, the driver uses the time zone of the Virtual Machine
2925+ * that is running the application.
2926+ * <P>
2927+ * The parameter value set by this method is stored internally and
2928+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
2929+ * object's command when the method <code>execute</code> is called.
2930+ * Methods such as <code>execute</code> and <code>populate</code> must be
2931+ * provided in any class that extends this class and implements one or
2932+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
2933+ * <P>
2934+ * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2935+ * as it is undefined in this class.
2936+ * <P>
2937+ * Calls made to the method <code>getParams</code> after this version of
2938+ * <code>setDate</code>
2939+ * has been called will return an array containing the parameter values that
2940+ * have been set. In that array, the element that represents the values
2941+ * set with this method will itself be an array. The first element of that array
2942+ * is the given <code>java.sql.Date</code> object.
2943+ * The second element is the value set for <i>cal</i>.
2944+ * The parameter number is indicated by an element's position in the array
2945+ * returned by the method <code>getParams</code>,
2946+ * with the first element being the value for the first placeholder parameter, the
2947+ * second element being the value for the second placeholder parameter, and so on.
2948+ * In other words, if the date being set is the value for the second
2949+ * placeholder parameter, the array containing it will be the second element in
2950+ * the array returned by <code>getParams</code>.
2951+ * <P>
2952+ * Note that because the numbering of elements in an array starts at zero,
2953+ * the array element that corresponds to placeholder parameter number
2954+ * <i>parameterIndex</i> is <i>parameterIndex</i> -1.
2955+ *
2956+ * @param parameterIndex the ordinal number of the placeholder parameter
2957+ * in this <code>RowSet</code> object's command that is to be set.
2958+ * The first parameter is 1, the second is 2, and so on; must be
2959+ * <code>1</code> or greater
2960+ * @param x a <code>java.sql.Date</code> object representing an SQL
2961+ * <code>DATE</code> value
2962+ * @param cal a <code>java.util.Calendar</code> object to use when
2963+ * when constructing the date
2964+ * @throws SQLException if an error occurs or the
2965+ * parameter index is out of bounds
2966+ * @see #getParams
2967+ */
2968+ public void setDate(int parameterIndex, java.sql.Date x, Calendar cal) throws SQLException {
2969+ Object date[];
2970+ checkParamIndex(parameterIndex);
2971+
2972+ date = new Object[2];
2973+ date[0] = x;
2974+ date[1] = cal;
2975+ if(params == null){
2976+ throw new SQLException("Set initParams() before setDate");
2977+ }
2978+ params.put(Integer.valueOf(parameterIndex - 1), date);
2979+ }
2980+
2981+ /**
2982+ * Sets the designated parameter to the given <code>java.sql.Time</code>
2983+ * object. The driver converts this
2984+ * to an SQL <code>TIME</code> value when it sends it to the database.
2985+ * <P>
2986+ * When the DBMS does not store time zone information, the driver will use
2987+ * the given <code>Calendar</code> object to construct the SQL <code>TIME</code>
2988+ * value to send to the database. With a
2989+ * <code>Calendar</code> object, the driver can calculate the date
2990+ * taking into account a custom time zone. If no <code>Calendar</code>
2991+ * object is specified, the driver uses the time zone of the Virtual Machine
2992+ * that is running the application.
2993+ * <P>
2994+ * The parameter value set by this method is stored internally and
2995+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
2996+ * object's command when the method <code>execute</code> is called.
2997+ * Methods such as <code>execute</code> and <code>populate</code> must be
2998+ * provided in any class that extends this class and implements one or
2999+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
3000+ * <P>
3001+ * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
3002+ * as it is undefined in this class.
3003+ * <P>
3004+ * Calls made to the method <code>getParams</code> after this version of
3005+ * <code>setTime</code>
3006+ * has been called will return an array containing the parameter values that
3007+ * have been set. In that array, the element that represents the values
3008+ * set with this method will itself be an array. The first element of that array
3009+ * is the given <code>java.sql.Time</code> object.
3010+ * The second element is the value set for <i>cal</i>.
3011+ * The parameter number is indicated by an element's position in the array
3012+ * returned by the method <code>getParams</code>,
3013+ * with the first element being the value for the first placeholder parameter, the
3014+ * second element being the value for the second placeholder parameter, and so on.
3015+ * In other words, if the time being set is the value for the second
3016+ * placeholder parameter, the array containing it will be the second element in
3017+ * the array returned by <code>getParams</code>.
3018+ * <P>
3019+ * Note that because the numbering of elements in an array starts at zero,
3020+ * the array element that corresponds to placeholder parameter number
3021+ * <i>parameterIndex</i> is <i>parameterIndex</i> -1.
3022+ *
3023+ * @param parameterIndex the ordinal number of the placeholder parameter
3024+ * in this <code>RowSet</code> object's command that is to be set.
3025+ * The first parameter is 1, the second is 2, and so on; must be
3026+ * <code>1</code> or greater
3027+ * @param x a <code>java.sql.Time</code> object
3028+ * @param cal the <code>java.util.Calendar</code> object the driver can use to
3029+ * construct the time
3030+ * @throws SQLException if an error occurs or the
3031+ * parameter index is out of bounds
3032+ * @see #getParams
3033+ */
3034+ public void setTime(int parameterIndex, java.sql.Time x, Calendar cal) throws SQLException {
3035+ Object time[];
3036+ checkParamIndex(parameterIndex);
3037+
3038+ time = new Object[2];
3039+ time[0] = x;
3040+ time[1] = cal;
3041+ if(params == null){
3042+ throw new SQLException("Set initParams() before setTime");
3043+ }
3044+ params.put(Integer.valueOf(parameterIndex - 1), time);
3045+ }
3046+
3047+ /**
3048+ * Sets the designated parameter to the given
3049+ * <code>java.sql.Timestamp</code> object. The driver converts this
3050+ * to an SQL <code>TIMESTAMP</code> value when it sends it to the database.
3051+ * <P>
3052+ * When the DBMS does not store time zone information, the driver will use
3053+ * the given <code>Calendar</code> object to construct the SQL <code>TIMESTAMP</code>
3054+ * value to send to the database. With a
3055+ * <code>Calendar</code> object, the driver can calculate the timestamp
3056+ * taking into account a custom time zone. If no <code>Calendar</code>
3057+ * object is specified, the driver uses the time zone of the Virtual Machine
3058+ * that is running the application.
3059+ * <P>
3060+ * The parameter value set by this method is stored internally and
3061+ * will be supplied as the appropriate parameter in this <code>RowSet</code>
3062+ * object's command when the method <code>execute</code> is called.
3063+ * Methods such as <code>execute</code> and <code>populate</code> must be
3064+ * provided in any class that extends this class and implements one or
3065+ * more of the standard JSR-114 <code>RowSet</code> interfaces.
3066+ * <P>
3067+ * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
3068+ * as it is undefined in this class.
3069+ * <P>
3070+ * Calls made to the method <code>getParams</code> after this version of
3071+ * <code>setTimestamp</code>
3072+ * has been called will return an array containing the parameter values that
3073+ * have been set. In that array, the element that represents the values
3074+ * set with this method will itself be an array. The first element of that array
3075+ * is the given <code>java.sql.Timestamp</code> object.
3076+ * The second element is the value set for <i>cal</i>.
3077+ * The parameter number is indicated by an element's position in the array
3078+ * returned by the method <code>getParams</code>,
3079+ * with the first element being the value for the first placeholder parameter, the
3080+ * second element being the value for the second placeholder parameter, and so on.
3081+ * In other words, if the timestamp being set is the value for the second
3082+ * placeholder parameter, the array containing it will be the second element in
3083+ * the array returned by <code>getParams</code>.
3084+ * <P>
3085+ * Note that because the numbering of elements in an array starts at zero,
3086+ * the array element that corresponds to placeholder parameter number
3087+ * <i>parameterIndex</i> is <i>parameterIndex</i> -1.
3088+ *
3089+ * @param parameterIndex the ordinal number of the placeholder parameter
3090+ * in this <code>RowSet</code> object's command that is to be set.
3091+ * The first parameter is 1, the second is 2, and so on; must be
3092+ * <code>1</code> or greater
3093+ * @param x a <code>java.sql.Timestamp</code> object
3094+ * @param cal the <code>java.util.Calendar</code> object the driver can use to
3095+ * construct the timestamp
3096+ * @throws SQLException if an error occurs or the
3097+ * parameter index is out of bounds
3098+ * @see #getParams
3099+ */
3100+ public void setTimestamp(int parameterIndex, java.sql.Timestamp x, Calendar cal) throws SQLException {
3101+ Object timestamp[];
3102+ checkParamIndex(parameterIndex);
3103+
3104+ timestamp = new Object[2];
3105+ timestamp[0] = x;
3106+ timestamp[1] = cal;
3107+ if(params == null){
3108+ throw new SQLException("Set initParams() before setTimestamp");
3109+ }
3110+ params.put(Integer.valueOf(parameterIndex - 1), timestamp);
3111+ }
3112+
3113+ /**
3114+ * Clears all of the current parameter values in this <code>RowSet</code>
3115+ * object's internal representation of the parameters to be set in
3116+ * this <code>RowSet</code> object's command when it is executed.
3117+ * <P>
3118+ * In general, parameter values remain in force for repeated use in
3119+ * this <code>RowSet</code> object's command. Setting a parameter value with the
3120+ * setter methods automatically clears the value of the
3121+ * designated parameter and replaces it with the new specified value.
3122+ * <P>
3123+ * This method is called internally by the <code>setCommand</code>
3124+ * method to clear all of the parameters set for the previous command.
3125+ * <P>
3126+ * Furthermore, this method differs from the <code>initParams</code>
3127+ * method in that it maintains the schema of the <code>RowSet</code> object.
3128+ *
3129+ * @throws SQLException if an error occurs clearing the parameters
3130+ */
3131+ public void clearParameters() throws SQLException {
3132+ params.clear();
3133+ }
3134+
3135+ /**
3136+ * Retrieves an array containing the parameter values (both Objects and
3137+ * primitives) that have been set for this
3138+ * <code>RowSet</code> object's command and throws an <code>SQLException</code> object
3139+ * if all parameters have not been set. Before the command is sent to the
3140+ * DBMS to be executed, these parameters will be substituted
3141+ * for placeholder parameters in the <code>PreparedStatement</code> object
3142+ * that is the command for a <code>RowSet</code> implementation extending
3143+ * the <code>BaseRowSet</code> class.
3144+ * <P>
3145+ * Each element in the array that is returned is an <code>Object</code> instance
3146+ * that contains the values of the parameters supplied to a setter method.
3147+ * The order of the elements is determined by the value supplied for
3148+ * <i>parameterIndex</i>. If the setter method takes only the parameter index
3149+ * and the value to be set (possibly null), the array element will contain the value to be set
3150+ * (which will be expressed as an <code>Object</code>). If there are additional
3151+ * parameters, the array element will itself be an array containing the value to be set
3152+ * plus any additional parameter values supplied to the setter method. If the method
3153+ * sets a stream, the array element includes the type of stream being supplied to the
3154+ * method. These additional parameters are for the use of the driver or the DBMS and may or
3155+ * may not be used.
3156+ * <P>
3157+ * NOTE: Stored parameter values of types <code>Array</code>, <code>Blob</code>,
3158+ * <code>Clob</code> and <code>Ref</code> are returned as <code>SerialArray</code>,
3159+ * <code>SerialBlob</code>, <code>SerialClob</code> and <code>SerialRef</code>
3160+ * respectively.
3161+ *
3162+ * @return an array of <code>Object</code> instances that includes the
3163+ * parameter values that may be set in this <code>RowSet</code> object's
3164+ * command; an empty array if no parameters have been set
3165+ * @throws SQLException if an error occurs retrieveing the object array of
3166+ * parameters of this <code>RowSet</code> object or if not all parameters have
3167+ * been set
3168+ */
3169+ public Object[] getParams() throws SQLException {
3170+ if (params == null) {
3171+
3172+ initParams();
3173+ Object [] paramsArray = new Object[params.size()];
3174+ return paramsArray;
3175+
3176+ } else {
3177+ // The parameters may be set in random order
3178+ // but all must be set, check to verify all
3179+ // have been set till the last parameter
3180+ // else throw exception.
3181+
3182+ Object[] paramsArray = new Object[params.size()];
3183+ for (int i = 0; i < params.size(); i++) {
3184+ paramsArray[i] = params.get(Integer.valueOf(i));
3185+ if (paramsArray[i] == null) {
3186+ throw new SQLException("missing parameter: " + (i + 1));
3187+ } //end if
3188+ } //end for
3189+ return paramsArray;
3190+
3191+ } //end if
3192+
3193+ } //end getParams
3194+
3195+
3196+ /**
3197+ * Sets the designated parameter to SQL <code>NULL</code>.
3198+ *
3199+ * <P><B>Note:</B> You must specify the parameter's SQL type.
3200+ *
3201+ * @param parameterName the name of the parameter
3202+ * @param sqlType the SQL type code defined in <code>java.sql.Types</code>
3203+ * @exception SQLException if a database access error occurs or
3204+ * this method is called on a closed <code>CallableStatement</code>
3205+ * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3206+ * this method
3207+ * @since 1.4
3208+ */
3209+ public void setNull(String parameterName, int sqlType) throws SQLException {
3210+ throw new SQLFeatureNotSupportedException("Feature not supported");
3211+ }
3212+
3213+
3214+ /**
3215+ * Sets the designated parameter to SQL <code>NULL</code>.
3216+ * This version of the method <code>setNull</code> should
3217+ * be used for user-defined types and REF type parameters. Examples
3218+ * of user-defined types include: STRUCT, DISTINCT, JAVA_OBJECT, and
3219+ * named array types.
3220+ *
3221+ * <P><B>Note:</B> To be portable, applications must give the
3222+ * SQL type code and the fully-qualified SQL type name when specifying
3223+ * a NULL user-defined or REF parameter. In the case of a user-defined type
3224+ * the name is the type name of the parameter itself. For a REF
3225+ * parameter, the name is the type name of the referenced type. If
3226+ * a JDBC driver does not need the type code or type name information,
3227+ * it may ignore it.
3228+ *
3229+ * Although it is intended for user-defined and Ref parameters,
3230+ * this method may be used to set a null parameter of any JDBC type.
3231+ * If the parameter does not have a user-defined or REF type, the given
3232+ * typeName is ignored.
3233+ *
3234+ *
3235+ * @param parameterName the name of the parameter
3236+ * @param sqlType a value from <code>java.sql.Types</code>
3237+ * @param typeName the fully-qualified name of an SQL user-defined type;
3238+ * ignored if the parameter is not a user-defined type or
3239+ * SQL <code>REF</code> value
3240+ * @exception SQLException if a database access error occurs or
3241+ * this method is called on a closed <code>CallableStatement</code>
3242+ * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3243+ * this method
3244+ * @since 1.4
3245+ */
3246+ public void setNull (String parameterName, int sqlType, String typeName)
3247+ throws SQLException{
3248+ throw new SQLFeatureNotSupportedException("Feature not supported");
3249+ }
3250+
3251+
3252+
3253+ /**
3254+ * Sets the designated parameter to the given Java <code>boolean</code> value.
3255+ * The driver converts this
3256+ * to an SQL <code>BIT</code> or <code>BOOLEAN</code> value when it sends it to the database.
3257+ *
3258+ * @param parameterName the name of the parameter
3259+ * @param x the parameter value
3260+ * @exception SQLException if a database access error occurs or
3261+ * this method is called on a closed <code>CallableStatement</code>
3262+ * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3263+ * this method
3264+ * @see #getParams
3265+ * @since 1.4
3266+ */
3267+ public void setBoolean(String parameterName, boolean x) throws SQLException{
3268+ throw new SQLFeatureNotSupportedException("Feature not supported");
3269+ }
3270+
3271+
3272+
3273+ /**
3274+ * Sets the designated parameter to the given Java <code>byte</code> value.
3275+ * The driver converts this
3276+ * to an SQL <code>TINYINT</code> value when it sends it to the database.
3277+ *
3278+ * @param parameterName the name of the parameter
3279+ * @param x the parameter value
3280+ * @exception SQLException if a database access error occurs or
3281+ * this method is called on a closed <code>CallableStatement</code>
3282+ * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3283+ * this method
3284+ * @see #getParams
3285+ * @since 1.4
3286+ */
3287+ public void setByte(String parameterName, byte x) throws SQLException{
3288+ throw new SQLFeatureNotSupportedException("Feature not supported");
3289+ }
3290+
3291+
3292+
3293+ /**
3294+ * Sets the designated parameter to the given Java <code>short</code> value.
3295+ * The driver converts this
3296+ * to an SQL <code>SMALLINT</code> value when it sends it to the database.
3297+ *
3298+ * @param parameterName the name of the parameter
3299+ * @param x the parameter value
3300+ * @exception SQLException if a database access error occurs or
3301+ * this method is called on a closed <code>CallableStatement</code>
3302+ * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3303+ * this method
3304+ * @see #getParams
3305+ * @since 1.4
3306+ */
3307+ public void setShort(String parameterName, short x) throws SQLException{
3308+ throw new SQLFeatureNotSupportedException("Feature not supported");
3309+ }
3310+
3311+
3312+ /**
3313+ * Sets the designated parameter to the given Java <code>int</code> value.
3314+ * The driver converts this
3315+ * to an SQL <code>INTEGER</code> value when it sends it to the database.
3316+ *
3317+ * @param parameterName the name of the parameter
3318+ * @param x the parameter value
3319+ * @exception SQLException if a database access error occurs or
3320+ * this method is called on a closed <code>CallableStatement</code>
3321+ * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3322+ * this method
3323+ * @see #getParams
3324+ * @since 1.4
3325+ */
3326+ public void setInt(String parameterName, int x) throws SQLException{
3327+ throw new SQLFeatureNotSupportedException("Feature not supported");
3328+ }
3329+
3330+
3331+ /**
3332+ * Sets the designated parameter to the given Java <code>long</code> value.
3333+ * The driver converts this
3334+ * to an SQL <code>BIGINT</code> value when it sends it to the database.
3335+ *
3336+ * @param parameterName the name of the parameter
3337+ * @param x the parameter value
3338+ * @exception SQLException if a database access error occurs or
3339+ * this method is called on a closed <code>CallableStatement</code>
3340+ * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3341+ * this method
3342+ * @see #getParams
3343+ * @since 1.4
3344+ */
3345+ public void setLong(String parameterName, long x) throws SQLException{
3346+ throw new SQLFeatureNotSupportedException("Feature not supported");
3347+ }
3348+
3349+
3350+ /**
3351+ * Sets the designated parameter to the given Java <code>float</code> value.
3352+ * The driver converts this
3353+ * to an SQL <code>FLOAT</code> value when it sends it to the database.
3354+ *
3355+ * @param parameterName the name of the parameter
3356+ * @param x the parameter value
3357+ * @exception SQLException if a database access error occurs or
3358+ * this method is called on a closed <code>CallableStatement</code>
3359+ * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3360+ * this method
3361+ * @see #getParams
3362+ * @since 1.4
3363+ */
3364+ public void setFloat(String parameterName, float x) throws SQLException{
3365+ throw new SQLFeatureNotSupportedException("Feature not supported");
3366+ }
3367+
3368+
3369+ /**
3370+ * Sets the designated parameter to the given Java <code>double</code> value.
3371+ * The driver converts this
3372+ * to an SQL <code>DOUBLE</code> value when it sends it to the database.
3373+ *
3374+ * @param parameterName the name of the parameter
3375+ * @param x the parameter value
3376+ * @exception SQLException if a database access error occurs or
3377+ * this method is called on a closed <code>CallableStatement</code>
3378+ * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3379+ * this method
3380+ * @see #getParams
3381+ * @since 1.4
3382+ */
3383+ public void setDouble(String parameterName, double x) throws SQLException{
3384+ throw new SQLFeatureNotSupportedException("Feature not supported");
3385+ }
3386+
3387+
3388+
3389+ /**
3390+ * Sets the designated parameter to the given
3391+ * <code>java.math.BigDecimal</code> value.
3392+ * The driver converts this to an SQL <code>NUMERIC</code> value when
3393+ * it sends it to the database.
3394+ *
3395+ * @param parameterName the name of the parameter
3396+ * @param x the parameter value
3397+ * @exception SQLException if a database access error occurs or
3398+ * this method is called on a closed <code>CallableStatement</code>
3399+ * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3400+ * this method
3401+ * @see #getParams
3402+ * @since 1.4
3403+ */
3404+ public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException{
3405+ throw new SQLFeatureNotSupportedException("Feature not supported");
3406+ }
3407+
3408+
3409+
3410+ /**
3411+ * Sets the designated parameter to the given Java <code>String</code> value.
3412+ * The driver converts this
3413+ * to an SQL <code>VARCHAR</code> or <code>LONGVARCHAR</code> value
3414+ * (depending on the argument's
3415+ * size relative to the driver's limits on <code>VARCHAR</code> values)
3416+ * when it sends it to the database.
3417+ *
3418+ * @param parameterName the name of the parameter
3419+ * @param x the parameter value
3420+ * @exception SQLException if a database access error occurs or
3421+ * this method is called on a closed <code>CallableStatement</code>
3422+ * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3423+ * this method
3424+ * @see #getParams
3425+ * @since 1.4
3426+ */
3427+ public void setString(String parameterName, String x) throws SQLException{
3428+ throw new SQLFeatureNotSupportedException("Feature not supported");
3429+ }
3430+
3431+
3432+
3433+ /**
3434+ * Sets the designated parameter to the given Java array of bytes.
3435+ * The driver converts this to an SQL <code>VARBINARY</code> or
3436+ * <code>LONGVARBINARY</code> (depending on the argument's size relative
3437+ * to the driver's limits on <code>VARBINARY</code> values) when it sends
3438+ * it to the database.
3439+ *
3440+ * @param parameterName the name of the parameter
3441+ * @param x the parameter value
3442+ * @exception SQLException if a database access error occurs or
3443+ * this method is called on a closed <code>CallableStatement</code>
3444+ * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3445+ * this method
3446+ * @see #getParams
3447+ * @since 1.4
3448+ */
3449+ public void setBytes(String parameterName, byte x[]) throws SQLException{
3450+ throw new SQLFeatureNotSupportedException("Feature not supported");
3451+ }
3452+
3453+
3454+
3455+ /**
3456+ * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value.
3457+ * The driver
3458+ * converts this to an SQL <code>TIMESTAMP</code> value when it sends it to the
3459+ * database.
3460+ *
3461+ * @param parameterName the name of the parameter
3462+ * @param x the parameter value
3463+ * @exception SQLException if a database access error occurs or
3464+ * this method is called on a closed <code>CallableStatement</code>
3465+ * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3466+ * this method
3467+ * @see #getParams
3468+ * @since 1.4
3469+ */
3470+ public void setTimestamp(String parameterName, java.sql.Timestamp x)
3471+ throws SQLException{
3472+ throw new SQLFeatureNotSupportedException("Feature not supported");
3473+ }
3474+
3475+
3476+
3477+ /**
3478+ * Sets the designated parameter to the given input stream, which will have
3479+ * the specified number of bytes.
3480+ * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
3481+ * parameter, it may be more practical to send it via a
3482+ * <code>java.io.InputStream</code>. Data will be read from the stream
3483+ * as needed until end-of-file is reached. The JDBC driver will
3484+ * do any necessary conversion from ASCII to the database char format.
3485+ *
3486+ * <P><B>Note:</B> This stream object can either be a standard
3487+ * Java stream object or your own subclass that implements the
3488+ * standard interface.
3489+ *
3490+ * @param parameterName the name of the parameter
3491+ * @param x the Java input stream that contains the ASCII parameter value
3492+ * @param length the number of bytes in the stream
3493+ * @exception SQLException if a database access error occurs or
3494+ * this method is called on a closed <code>CallableStatement</code>
3495+ * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3496+ * this method
3497+ * @since 1.4
3498+ */
3499+ public void setAsciiStream(String parameterName, java.io.InputStream x, int length)
3500+ throws SQLException{
3501+ throw new SQLFeatureNotSupportedException("Feature not supported");
3502+ }
3503+
3504+
3505+ /**
3506+ * Sets the designated parameter to the given input stream, which will have
3507+ * the specified number of bytes.
3508+ * When a very large binary value is input to a <code>LONGVARBINARY</code>
3509+ * parameter, it may be more practical to send it via a
3510+ * <code>java.io.InputStream</code> object. The data will be read from the stream
3511+ * as needed until end-of-file is reached.
3512+ *
3513+ * <P><B>Note:</B> This stream object can either be a standard
3514+ * Java stream object or your own subclass that implements the
3515+ * standard interface.
3516+ *
3517+ * @param parameterName the name of the parameter
3518+ * @param x the java input stream which contains the binary parameter value
3519+ * @param length the number of bytes in the stream
3520+ * @exception SQLException if a database access error occurs or
3521+ * this method is called on a closed <code>CallableStatement</code>
3522+ * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3523+ * this method
3524+ * @since 1.4
3525+ */
3526+ public void setBinaryStream(String parameterName, java.io.InputStream x,
3527+ int length) throws SQLException{
3528+ throw new SQLFeatureNotSupportedException("Feature not supported");
3529+ }
3530+
3531+
3532+ /**
3533+ * Sets the designated parameter to the given <code>Reader</code>
3534+ * object, which is the given number of characters long.
3535+ * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
3536+ * parameter, it may be more practical to send it via a
3537+ * <code>java.io.Reader</code> object. The data will be read from the stream
3538+ * as needed until end-of-file is reached. The JDBC driver will
3539+ * do any necessary conversion from UNICODE to the database char format.
3540+ *
3541+ * <P><B>Note:</B> This stream object can either be a standard
3542+ * Java stream object or your own subclass that implements the
3543+ * standard interface.
3544+ *
3545+ * @param parameterName the name of the parameter
3546+ * @param reader the <code>java.io.Reader</code> object that
3547+ * contains the UNICODE data used as the designated parameter
3548+ * @param length the number of characters in the stream
3549+ * @exception SQLException if a database access error occurs or
3550+ * this method is called on a closed <code>CallableStatement</code>
3551+ * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3552+ * this method
3553+ * @since 1.4
3554+ */
3555+ public void setCharacterStream(String parameterName,
3556+ java.io.Reader reader,
3557+ int length) throws SQLException{
3558+ throw new SQLFeatureNotSupportedException("Feature not supported");
3559+ }
3560+
3561+
3562+ /**
3563+ * Sets the designated parameter to the given input stream.
3564+ * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
3565+ * parameter, it may be more practical to send it via a
3566+ * <code>java.io.InputStream</code>. Data will be read from the stream
3567+ * as needed until end-of-file is reached. The JDBC driver will
3568+ * do any necessary conversion from ASCII to the database char format.
3569+ *
3570+ * <P><B>Note:</B> This stream object can either be a standard
3571+ * Java stream object or your own subclass that implements the
3572+ * standard interface.
3573+ * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3574+ * it might be more efficient to use a version of
3575+ * <code>setAsciiStream</code> which takes a length parameter.
3576+ *
3577+ * @param parameterName the name of the parameter
3578+ * @param x the Java input stream that contains the ASCII parameter value
3579+ * @exception SQLException if a database access error occurs or
3580+ * this method is called on a closed <code>CallableStatement</code>
3581+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
3582+ * @since 1.6
3583+ */
3584+ public void setAsciiStream(String parameterName, java.io.InputStream x)
3585+ throws SQLException{
3586+ throw new SQLFeatureNotSupportedException("Feature not supported");
3587+ }
3588+
3589+
3590+ /**
3591+ * Sets the designated parameter to the given input stream.
3592+ * When a very large binary value is input to a <code>LONGVARBINARY</code>
3593+ * parameter, it may be more practical to send it via a
3594+ * <code>java.io.InputStream</code> object. The data will be read from the
3595+ * stream as needed until end-of-file is reached.
3596+ *
3597+ * <P><B>Note:</B> This stream object can either be a standard
3598+ * Java stream object or your own subclass that implements the
3599+ * standard interface.
3600+ * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3601+ * it might be more efficient to use a version of
3602+ * <code>setBinaryStream</code> which takes a length parameter.
3603+ *
3604+ * @param parameterName the name of the parameter
3605+ * @param x the java input stream which contains the binary parameter value
3606+ * @exception SQLException if a database access error occurs or
3607+ * this method is called on a closed <code>CallableStatement</code>
3608+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
3609+ * @since 1.6
3610+ */
3611+ public void setBinaryStream(String parameterName, java.io.InputStream x)
3612+ throws SQLException{
3613+ throw new SQLFeatureNotSupportedException("Feature not supported");
3614+ }
3615+
3616+
3617+
3618+ /**
3619+ * Sets the designated parameter to the given <code>Reader</code>
3620+ * object.
3621+ * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
3622+ * parameter, it may be more practical to send it via a
3623+ * <code>java.io.Reader</code> object. The data will be read from the stream
3624+ * as needed until end-of-file is reached. The JDBC driver will
3625+ * do any necessary conversion from UNICODE to the database char format.
3626+ *
3627+ * <P><B>Note:</B> This stream object can either be a standard
3628+ * Java stream object or your own subclass that implements the
3629+ * standard interface.
3630+ * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3631+ * it might be more efficient to use a version of
3632+ * <code>setCharacterStream</code> which takes a length parameter.
3633+ *
3634+ * @param parameterName the name of the parameter
3635+ * @param reader the <code>java.io.Reader</code> object that contains the
3636+ * Unicode data
3637+ * @exception SQLException if a database access error occurs or
3638+ * this method is called on a closed <code>CallableStatement</code>
3639+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
3640+ * @since 1.6
3641+ */
3642+ public void setCharacterStream(String parameterName,
3643+ java.io.Reader reader) throws SQLException{
3644+ throw new SQLFeatureNotSupportedException("Feature not supported");
3645+ }
3646+
3647+
3648+ /**
3649+ * Sets the designated parameter in this <code>RowSet</code> object's command
3650+ * to a <code>Reader</code> object. The
3651+ * <code>Reader</code> reads the data till end-of-file is reached. The
3652+ * driver does the necessary conversion from Java character format to
3653+ * the national character set in the database.
3654+
3655+ * <P><B>Note:</B> This stream object can either be a standard
3656+ * Java stream object or your own subclass that implements the
3657+ * standard interface.
3658+ * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3659+ * it might be more efficient to use a version of
3660+ * <code>setNCharacterStream</code> which takes a length parameter.
3661+ *
3662+ * @param parameterIndex of the first parameter is 1, the second is 2, ...
3663+ * @param value the parameter value
3664+ * @throws SQLException if the driver does not support national
3665+ * character sets; if the driver can detect that a data conversion
3666+ * error could occur ; if a database access error occurs; or
3667+ * this method is called on a closed <code>PreparedStatement</code>
3668+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
3669+ * @since 1.6
3670+ */
3671+ public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException{
3672+ throw new SQLFeatureNotSupportedException("Feature not supported");
3673+ }
3674+
3675+
3676+
3677+ /**
3678+ * Sets the value of the designated parameter with the given object. The second
3679+ * argument must be an object type; for integral values, the
3680+ * <code>java.lang</code> equivalent objects should be used.
3681+ *
3682+ * <p>The given Java object will be converted to the given targetSqlType
3683+ * before being sent to the database.
3684+ *
3685+ * If the object has a custom mapping (is of a class implementing the
3686+ * interface <code>SQLData</code>),
3687+ * the JDBC driver should call the method <code>SQLData.writeSQL</code> to write it
3688+ * to the SQL data stream.
3689+ * If, on the other hand, the object is of a class implementing
3690+ * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>, <code>NClob</code>,
3691+ * <code>Struct</code>, <code>java.net.URL</code>,
3692+ * or <code>Array</code>, the driver should pass it to the database as a
3693+ * value of the corresponding SQL type.
3694+ * <P>
3695+ * Note that this method may be used to pass datatabase-
3696+ * specific abstract data types.
3697+ *
3698+ * @param parameterName the name of the parameter
3699+ * @param x the object containing the input parameter value
3700+ * @param targetSqlType the SQL type (as defined in java.sql.Types) to be
3701+ * sent to the database. The scale argument may further qualify this type.
3702+ * @param scale for java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types,
3703+ * this is the number of digits after the decimal point. For all other
3704+ * types, this value will be ignored.
3705+ * @exception SQLException if a database access error occurs or
3706+ * this method is called on a closed <code>CallableStatement</code>
3707+ * @exception SQLFeatureNotSupportedException if <code>targetSqlType</code> is
3708+ * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>,
3709+ * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,
3710+ * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,
3711+ * <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>
3712+ * or <code>STRUCT</code> data type and the JDBC driver does not support
3713+ * this data type
3714+ * @see Types
3715+ * @see #getParams
3716+ * @since 1.4
3717+ */
3718+ public void setObject(String parameterName, Object x, int targetSqlType, int scale)
3719+ throws SQLException{
3720+ throw new SQLFeatureNotSupportedException("Feature not supported");
3721+ }
3722+
3723+
3724+
3725+ /**
3726+ * Sets the value of the designated parameter with the given object.
3727+ * This method is like the method <code>setObject</code>
3728+ * above, except that it assumes a scale of zero.
3729+ *
3730+ * @param parameterName the name of the parameter
3731+ * @param x the object containing the input parameter value
3732+ * @param targetSqlType the SQL type (as defined in java.sql.Types) to be
3733+ * sent to the database
3734+ * @exception SQLException if a database access error occurs or
3735+ * this method is called on a closed <code>CallableStatement</code>
3736+ * @exception SQLFeatureNotSupportedException if <code>targetSqlType</code> is
3737+ * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>,
3738+ * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,
3739+ * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,
3740+ * <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>
3741+ * or <code>STRUCT</code> data type and the JDBC driver does not support
3742+ * this data type
3743+ * @see #getParams
3744+ * @since 1.4
3745+ */
3746+ public void setObject(String parameterName, Object x, int targetSqlType)
3747+ throws SQLException{
3748+ throw new SQLFeatureNotSupportedException("Feature not supported");
3749+ }
3750+
3751+
3752+ /**
3753+ * Sets the value of the designated parameter with the given object.
3754+ * The second parameter must be of type <code>Object</code>; therefore, the
3755+ * <code>java.lang</code> equivalent objects should be used for built-in types.
3756+ *
3757+ * <p>The JDBC specification specifies a standard mapping from
3758+ * Java <code>Object</code> types to SQL types. The given argument
3759+ * will be converted to the corresponding SQL type before being
3760+ * sent to the database.
3761+ *
3762+ * <p>Note that this method may be used to pass datatabase-
3763+ * specific abstract data types, by using a driver-specific Java
3764+ * type.
3765+ *
3766+ * If the object is of a class implementing the interface <code>SQLData</code>,
3767+ * the JDBC driver should call the method <code>SQLData.writeSQL</code>
3768+ * to write it to the SQL data stream.
3769+ * If, on the other hand, the object is of a class implementing
3770+ * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>, <code>NClob</code>,
3771+ * <code>Struct</code>, <code>java.net.URL</code>,
3772+ * or <code>Array</code>, the driver should pass it to the database as a
3773+ * value of the corresponding SQL type.
3774+ * <P>
3775+ * This method throws an exception if there is an ambiguity, for example, if the
3776+ * object is of a class implementing more than one of the interfaces named above.
3777+ *
3778+ * @param parameterName the name of the parameter
3779+ * @param x the object containing the input parameter value
3780+ * @exception SQLException if a database access error occurs,
3781+ * this method is called on a closed <code>CallableStatement</code> or if the given
3782+ * <code>Object</code> parameter is ambiguous
3783+ * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3784+ * this method
3785+ * @see #getParams
3786+ * @since 1.4
3787+ */
3788+ public void setObject(String parameterName, Object x) throws SQLException{
3789+ throw new SQLFeatureNotSupportedException("Feature not supported");
3790+ }
3791+
3792+
3793+
3794+ /**
3795+ * Sets the designated parameter to a <code>InputStream</code> object. The inputstream must contain the number
3796+ * of characters specified by length otherwise a <code>SQLException</code> will be
3797+ * generated when the <code>PreparedStatement</code> is executed.
3798+ * This method differs from the <code>setBinaryStream (int, InputStream, int)</code>
3799+ * method because it informs the driver that the parameter value should be
3800+ * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used,
3801+ * the driver may have to do extra work to determine whether the parameter
3802+ * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
3803+ * @param parameterIndex index of the first parameter is 1,
3804+ * the second is 2, ...
3805+ * @param inputStream An object that contains the data to set the parameter
3806+ * value to.
3807+ * @param length the number of bytes in the parameter data.
3808+ * @throws SQLException if a database access error occurs,
3809+ * this method is called on a closed <code>PreparedStatement</code>,
3810+ * if parameterIndex does not correspond
3811+ * to a parameter marker in the SQL statement, if the length specified
3812+ * is less than zero or if the number of bytes in the inputstream does not match
3813+ * the specfied length.
3814+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
3815+ *
3816+ * @since 1.6
3817+ */
3818+ public void setBlob(int parameterIndex, InputStream inputStream, long length)
3819+ throws SQLException{
3820+ throw new SQLFeatureNotSupportedException("Feature not supported");
3821+ }
3822+
3823+
3824+ /**
3825+ * Sets the designated parameter to a <code>InputStream</code> object.
3826+ * This method differs from the <code>setBinaryStream (int, InputStream)</code>
3827+ * method because it informs the driver that the parameter value should be
3828+ * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used,
3829+ * the driver may have to do extra work to determine whether the parameter
3830+ * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
3831+ *
3832+ * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3833+ * it might be more efficient to use a version of
3834+ * <code>setBlob</code> which takes a length parameter.
3835+ *
3836+ * @param parameterIndex index of the first parameter is 1,
3837+ * the second is 2, ...
3838+ * @param inputStream An object that contains the data to set the parameter
3839+ * value to.
3840+ * @throws SQLException if a database access error occurs,
3841+ * this method is called on a closed <code>PreparedStatement</code> or
3842+ * if parameterIndex does not correspond
3843+ * to a parameter marker in the SQL statement,
3844+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
3845+ *
3846+ * @since 1.6
3847+ */
3848+ public void setBlob(int parameterIndex, InputStream inputStream)
3849+ throws SQLException{
3850+ throw new SQLFeatureNotSupportedException("Feature not supported");
3851+ }
3852+
3853+
3854+ /**
3855+ * Sets the designated parameter to a <code>InputStream</code> object. The <code>inputstream</code> must contain the number
3856+ * of characters specified by length, otherwise a <code>SQLException</code> will be
3857+ * generated when the <code>CallableStatement</code> is executed.
3858+ * This method differs from the <code>setBinaryStream (int, InputStream, int)</code>
3859+ * method because it informs the driver that the parameter value should be
3860+ * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used,
3861+ * the driver may have to do extra work to determine whether the parameter
3862+ * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
3863+ *
3864+ * @param parameterName the name of the parameter to be set
3865+ * the second is 2, ...
3866+ *
3867+ * @param inputStream An object that contains the data to set the parameter
3868+ * value to.
3869+ * @param length the number of bytes in the parameter data.
3870+ * @throws SQLException if parameterIndex does not correspond
3871+ * to a parameter marker in the SQL statement, or if the length specified
3872+ * is less than zero; if the number of bytes in the inputstream does not match
3873+ * the specfied length; if a database access error occurs or
3874+ * this method is called on a closed <code>CallableStatement</code>
3875+ * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3876+ * this method
3877+ *
3878+ * @since 1.6
3879+ */
3880+ public void setBlob(String parameterName, InputStream inputStream, long length)
3881+ throws SQLException{
3882+ throw new SQLFeatureNotSupportedException("Feature not supported");
3883+ }
3884+
3885+
3886+ /**
3887+ * Sets the designated parameter to the given <code>java.sql.Blob</code> object.
3888+ * The driver converts this to an SQL <code>BLOB</code> value when it
3889+ * sends it to the database.
3890+ *
3891+ * @param parameterName the name of the parameter
3892+ * @param x a <code>Blob</code> object that maps an SQL <code>BLOB</code> value
3893+ * @exception SQLException if a database access error occurs or
3894+ * this method is called on a closed <code>CallableStatement</code>
3895+ * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3896+ * this method
3897+ * @since 1.6
3898+ */
3899+ public void setBlob (String parameterName, Blob x) throws SQLException{
3900+ throw new SQLFeatureNotSupportedException("Feature not supported");
3901+ }
3902+
3903+
3904+ /**
3905+ * Sets the designated parameter to a <code>InputStream</code> object.
3906+ * This method differs from the <code>setBinaryStream (int, InputStream)</code>
3907+ * method because it informs the driver that the parameter value should be
3908+ * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used,
3909+ * the driver may have to do extra work to determine whether the parameter
3910+ * data should be send to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
3911+ *
3912+ * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3913+ * it might be more efficient to use a version of
3914+ * <code>setBlob</code> which takes a length parameter.
3915+ *
3916+ * @param parameterName the name of the parameter
3917+ * @param inputStream An object that contains the data to set the parameter
3918+ * value to.
3919+ * @throws SQLException if a database access error occurs or
3920+ * this method is called on a closed <code>CallableStatement</code>
3921+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
3922+ *
3923+ * @since 1.6
3924+ */
3925+ public void setBlob(String parameterName, InputStream inputStream)
3926+ throws SQLException{
3927+ throw new SQLFeatureNotSupportedException("Feature not supported");
3928+ }
3929+
3930+
3931+ /**
3932+ * Sets the designated parameter to a <code>Reader</code> object. The reader must contain the number
3933+ * of characters specified by length otherwise a <code>SQLException</code> will be
3934+ * generated when the <code>PreparedStatement</code> is executed.
3935+ *This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
3936+ * because it informs the driver that the parameter value should be sent to
3937+ * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the
3938+ * driver may have to do extra work to determine whether the parameter
3939+ * data should be sent to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
3940+ * @param parameterIndex index of the first parameter is 1, the second is 2, ...
3941+ * @param reader An object that contains the data to set the parameter value to.
3942+ * @param length the number of characters in the parameter data.
3943+ * @throws SQLException if a database access error occurs, this method is called on
3944+ * a closed <code>PreparedStatement</code>, if parameterIndex does not correspond to a parameter
3945+ * marker in the SQL statement, or if the length specified is less than zero.
3946+ *
3947+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
3948+ * @since 1.6
3949+ */
3950+ public void setClob(int parameterIndex, Reader reader, long length)
3951+ throws SQLException{
3952+ throw new SQLFeatureNotSupportedException("Feature not supported");
3953+ }
3954+
3955+
3956+/**
3957+ * Sets the designated parameter to a <code>Reader</code> object.
3958+ * This method differs from the <code>setCharacterStream (int, Reader)</code> method
3959+ * because it informs the driver that the parameter value should be sent to
3960+ * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the
3961+ * driver may have to do extra work to determine whether the parameter
3962+ * data should be sent to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
3963+ *
3964+ * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3965+ * it might be more efficient to use a version of
3966+ * <code>setClob</code> which takes a length parameter.
3967+ *
3968+ * @param parameterIndex index of the first parameter is 1, the second is 2, ...
3969+ * @param reader An object that contains the data to set the parameter value to.
3970+ * @throws SQLException if a database access error occurs, this method is called on
3971+ * a closed <code>PreparedStatement</code>or if parameterIndex does not correspond to a parameter
3972+ * marker in the SQL statement
3973+ *
3974+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
3975+ * @since 1.6
3976+ */
3977+ public void setClob(int parameterIndex, Reader reader)
3978+ throws SQLException{
3979+ throw new SQLFeatureNotSupportedException("Feature not supported");
3980+ }
3981+
3982+
3983+ /**
3984+ * Sets the designated parameter to a <code>Reader</code> object. The <code>reader</code> must contain the number
3985+ * of characters specified by length otherwise a <code>SQLException</code> will be
3986+ * generated when the <code>CallableStatement</code> is executed.
3987+ * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
3988+ * because it informs the driver that the parameter value should be sent to
3989+ * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the
3990+ * driver may have to do extra work to determine whether the parameter
3991+ * data should be send to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
3992+ * @param parameterName the name of the parameter to be set
3993+ * @param reader An object that contains the data to set the parameter value to.
3994+ * @param length the number of characters in the parameter data.
3995+ * @throws SQLException if parameterIndex does not correspond to a parameter
3996+ * marker in the SQL statement; if the length specified is less than zero;
3997+ * a database access error occurs or
3998+ * this method is called on a closed <code>CallableStatement</code>
3999+ * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
4000+ * this method
4001+ *
4002+ * @since 1.6
4003+ */
4004+ public void setClob(String parameterName, Reader reader, long length)
4005+ throws SQLException{
4006+ throw new SQLFeatureNotSupportedException("Feature not supported");
4007+ }
4008+
4009+
4010+ /**
4011+ * Sets the designated parameter to the given <code>java.sql.Clob</code> object.
4012+ * The driver converts this to an SQL <code>CLOB</code> value when it
4013+ * sends it to the database.
4014+ *
4015+ * @param parameterName the name of the parameter
4016+ * @param x a <code>Clob</code> object that maps an SQL <code>CLOB</code> value
4017+ * @exception SQLException if a database access error occurs or
4018+ * this method is called on a closed <code>CallableStatement</code>
4019+ * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
4020+ * this method
4021+ * @since 1.6
4022+ */
4023+ public void setClob (String parameterName, Clob x) throws SQLException{
4024+ throw new SQLFeatureNotSupportedException("Feature not supported");
4025+ }
4026+
4027+
4028+ /**
4029+ * Sets the designated parameter to a <code>Reader</code> object.
4030+ * This method differs from the <code>setCharacterStream (int, Reader)</code> method
4031+ * because it informs the driver that the parameter value should be sent to
4032+ * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the
4033+ * driver may have to do extra work to determine whether the parameter
4034+ * data should be send to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
4035+ *
4036+ * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
4037+ * it might be more efficient to use a version of
4038+ * <code>setClob</code> which takes a length parameter.
4039+ *
4040+ * @param parameterName the name of the parameter
4041+ * @param reader An object that contains the data to set the parameter value to.
4042+ * @throws SQLException if a database access error occurs or this method is called on
4043+ * a closed <code>CallableStatement</code>
4044+ *
4045+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
4046+ * @since 1.6
4047+ */
4048+ public void setClob(String parameterName, Reader reader)
4049+ throws SQLException{
4050+ throw new SQLFeatureNotSupportedException("Feature not supported");
4051+ }
4052+
4053+
4054+ /**
4055+ * Sets the designated parameter to the given <code>java.sql.Date</code> value
4056+ * using the default time zone of the virtual machine that is running
4057+ * the application.
4058+ * The driver converts this
4059+ * to an SQL <code>DATE</code> value when it sends it to the database.
4060+ *
4061+ * @param parameterName the name of the parameter
4062+ * @param x the parameter value
4063+ * @exception SQLException if a database access error occurs or
4064+ * this method is called on a closed <code>CallableStatement</code>
4065+ * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
4066+ * this method
4067+ * @see #getParams
4068+ * @since 1.4
4069+ */
4070+ public void setDate(String parameterName, java.sql.Date x)
4071+ throws SQLException{
4072+ throw new SQLFeatureNotSupportedException("Feature not supported");
4073+ }
4074+
4075+
4076+ /**
4077+ * Sets the designated parameter to the given <code>java.sql.Date</code> value,
4078+ * using the given <code>Calendar</code> object. The driver uses
4079+ * the <code>Calendar</code> object to construct an SQL <code>DATE</code> value,
4080+ * which the driver then sends to the database. With a
4081+ * a <code>Calendar</code> object, the driver can calculate the date
4082+ * taking into account a custom timezone. If no
4083+ * <code>Calendar</code> object is specified, the driver uses the default
4084+ * timezone, which is that of the virtual machine running the application.
4085+ *
4086+ * @param parameterName the name of the parameter
4087+ * @param x the parameter value
4088+ * @param cal the <code>Calendar</code> object the driver will use
4089+ * to construct the date
4090+ * @exception SQLException if a database access error occurs or
4091+ * this method is called on a closed <code>CallableStatement</code>
4092+ * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
4093+ * this method
4094+ * @see #getParams
4095+ * @since 1.4
4096+ */
4097+ public void setDate(String parameterName, java.sql.Date x, Calendar cal)
4098+ throws SQLException{
4099+ throw new SQLFeatureNotSupportedException("Feature not supported");
4100+ }
4101+
4102+
4103+ /**
4104+ * Sets the designated parameter to the given <code>java.sql.Time</code> value.
4105+ * The driver converts this
4106+ * to an SQL <code>TIME</code> value when it sends it to the database.
4107+ *
4108+ * @param parameterName the name of the parameter
4109+ * @param x the parameter value
4110+ * @exception SQLException if a database access error occurs or
4111+ * this method is called on a closed <code>CallableStatement</code>
4112+ * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
4113+ * this method
4114+ * @see #getParams
4115+ * @since 1.4
4116+ */
4117+ public void setTime(String parameterName, java.sql.Time x)
4118+ throws SQLException{
4119+ throw new SQLFeatureNotSupportedException("Feature not supported");
4120+ }
4121+
4122+
4123+ /**
4124+ * Sets the designated parameter to the given <code>java.sql.Time</code> value,
4125+ * using the given <code>Calendar</code> object. The driver uses
4126+ * the <code>Calendar</code> object to construct an SQL <code>TIME</code> value,
4127+ * which the driver then sends to the database. With a
4128+ * a <code>Calendar</code> object, the driver can calculate the time
4129+ * taking into account a custom timezone. If no
4130+ * <code>Calendar</code> object is specified, the driver uses the default
4131+ * timezone, which is that of the virtual machine running the application.
4132+ *
4133+ * @param parameterName the name of the parameter
4134+ * @param x the parameter value
4135+ * @param cal the <code>Calendar</code> object the driver will use
4136+ * to construct the time
4137+ * @exception SQLException if a database access error occurs or
4138+ * this method is called on a closed <code>CallableStatement</code>
4139+ * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
4140+ * this method
4141+ * @see #getParams
4142+ * @since 1.4
4143+ */
4144+ public void setTime(String parameterName, java.sql.Time x, Calendar cal)
4145+ throws SQLException{
4146+ throw new SQLFeatureNotSupportedException("Feature not supported");
4147+ }
4148+
4149+
4150+ /**
4151+ * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value,
4152+ * using the given <code>Calendar</code> object. The driver uses
4153+ * the <code>Calendar</code> object to construct an SQL <code>TIMESTAMP</code> value,
4154+ * which the driver then sends to the database. With a
4155+ * a <code>Calendar</code> object, the driver can calculate the timestamp
4156+ * taking into account a custom timezone. If no
4157+ * <code>Calendar</code> object is specified, the driver uses the default
4158+ * timezone, which is that of the virtual machine running the application.
4159+ *
4160+ * @param parameterName the name of the parameter
4161+ * @param x the parameter value
4162+ * @param cal the <code>Calendar</code> object the driver will use
4163+ * to construct the timestamp
4164+ * @exception SQLException if a database access error occurs or
4165+ * this method is called on a closed <code>CallableStatement</code>
4166+ * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
4167+ * this method
4168+ * @see #getParams
4169+ * @since 1.4
4170+ */
4171+ public void setTimestamp(String parameterName, java.sql.Timestamp x, Calendar cal)
4172+ throws SQLException{
4173+ throw new SQLFeatureNotSupportedException("Feature not supported");
4174+ }
4175+
4176+
4177+ /**
4178+ * Sets the designated parameter to the given <code>java.sql.SQLXML</code> object. The driver converts this to an
4179+ * SQL <code>XML</code> value when it sends it to the database.
4180+ * @param parameterIndex index of the first parameter is 1, the second is 2, ...
4181+ * @param xmlObject a <code>SQLXML</code> object that maps an SQL <code>XML</code> value
4182+ * @throws SQLException if a database access error occurs, this method
4183+ * is called on a closed result set,
4184+ * the <code>java.xml.transform.Result</code>,
4185+ * <code>Writer</code> or <code>OutputStream</code> has not been closed
4186+ * for the <code>SQLXML</code> object or
4187+ * if there is an error processing the XML value. The <code>getCause</code> method
4188+ * of the exception may provide a more detailed exception, for example, if the
4189+ * stream does not contain valid XML.
4190+ * @since 1.6
4191+ */
4192+ public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException{
4193+ throw new SQLFeatureNotSupportedException("Feature not supported");
4194+ }
4195+
4196+
4197+ /**
4198+ * Sets the designated parameter to the given <code>java.sql.SQLXML</code> object. The driver converts this to an
4199+ * <code>SQL XML</code> value when it sends it to the database.
4200+ * @param parameterName the name of the parameter
4201+ * @param xmlObject a <code>SQLXML</code> object that maps an <code>SQL XML</code> value
4202+ * @throws SQLException if a database access error occurs, this method
4203+ * is called on a closed result set,
4204+ * the <code>java.xml.transform.Result</code>,
4205+ * <code>Writer</code> or <code>OutputStream</code> has not been closed
4206+ * for the <code>SQLXML</code> object or
4207+ * if there is an error processing the XML value. The <code>getCause</code> method
4208+ * of the exception may provide a more detailed exception, for example, if the
4209+ * stream does not contain valid XML.
4210+ * @since 1.6
4211+ */
4212+ public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException{
4213+ throw new SQLFeatureNotSupportedException("Feature not supported");
4214+ }
4215+
4216+
4217+ /**
4218+ * Sets the designated parameter to the given <code>java.sql.RowId</code> object. The
4219+ * driver converts this to a SQL <code>ROWID</code> value when it sends it
4220+ * to the database
4221+ *
4222+ * @param parameterIndex the first parameter is 1, the second is 2, ...
4223+ * @param x the parameter value
4224+ * @throws SQLException if a database access error occurs
4225+ *
4226+ * @since 1.6
4227+ */
4228+ public void setRowId(int parameterIndex, RowId x) throws SQLException{
4229+ throw new SQLFeatureNotSupportedException("Feature not supported");
4230+ }
4231+
4232+
4233+ /**
4234+ * Sets the designated parameter to the given <code>java.sql.RowId</code> object. The
4235+ * driver converts this to a SQL <code>ROWID</code> when it sends it to the
4236+ * database.
4237+ *
4238+ * @param parameterName the name of the parameter
4239+ * @param x the parameter value
4240+ * @throws SQLException if a database access error occurs
4241+ * @since 1.6
4242+ */
4243+ public void setRowId(String parameterName, RowId x) throws SQLException{
4244+ throw new SQLFeatureNotSupportedException("Feature not supported");
4245+ }
4246+
4247+ /**
4248+ * Sets the designated paramter to the given <code>String</code> object.
4249+ * The driver converts this to a SQL <code>NCHAR</code> or
4250+ * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code> value
4251+ * (depending on the argument's
4252+ * size relative to the driver's limits on <code>NVARCHAR</code> values)
4253+ * when it sends it to the database.
4254+ *
4255+ * @param parameterIndex of the first parameter is 1, the second is 2, ...
4256+ * @param value the parameter value
4257+ * @throws SQLException if the driver does not support national
4258+ * character sets; if the driver can detect that a data conversion
4259+ * error could occur ; or if a database access error occurs
4260+ * @since 1.6
4261+ */
4262+ public void setNString(int parameterIndex, String value) throws SQLException{
4263+ throw new SQLFeatureNotSupportedException("Feature not supported");
4264+ }
4265+
4266+
4267+ /**
4268+ * Sets the designated paramter to the given <code>String</code> object.
4269+ * The driver converts this to a SQL <code>NCHAR</code> or
4270+ * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code>
4271+ * @param parameterName the name of the column to be set
4272+ * @param value the parameter value
4273+ * @throws SQLException if the driver does not support national
4274+ * character sets; if the driver can detect that a data conversion
4275+ * error could occur; or if a database access error occurs
4276+ * @since 1.6
4277+ */
4278+ public void setNString(String parameterName, String value)
4279+ throws SQLException{
4280+ throw new SQLFeatureNotSupportedException("Feature not supported");
4281+ }
4282+
4283+
4284+ /**
4285+ * Sets the designated parameter to a <code>Reader</code> object. The
4286+ * <code>Reader</code> reads the data till end-of-file is reached. The
4287+ * driver does the necessary conversion from Java character format to
4288+ * the national character set in the database.
4289+ * @param parameterIndex of the first parameter is 1, the second is 2, ...
4290+ * @param value the parameter value
4291+ * @param length the number of characters in the parameter data.
4292+ * @throws SQLException if the driver does not support national
4293+ * character sets; if the driver can detect that a data conversion
4294+ * error could occur ; or if a database access error occurs
4295+ * @since 1.6
4296+ */
4297+ public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException{
4298+ throw new SQLFeatureNotSupportedException("Feature not supported");
4299+ }
4300+
4301+
4302+ /**
4303+ * Sets the designated parameter to a <code>Reader</code> object. The
4304+ * <code>Reader</code> reads the data till end-of-file is reached. The
4305+ * driver does the necessary conversion from Java character format to
4306+ * the national character set in the database.
4307+ * @param parameterName the name of the column to be set
4308+ * @param value the parameter value
4309+ * @param length the number of characters in the parameter data.
4310+ * @throws SQLException if the driver does not support national
4311+ * character sets; if the driver can detect that a data conversion
4312+ * error could occur; or if a database access error occurs
4313+ * @since 1.6
4314+ */
4315+ public void setNCharacterStream(String parameterName, Reader value, long length)
4316+ throws SQLException{
4317+ throw new SQLFeatureNotSupportedException("Feature not supported");
4318+ }
4319+
4320+
4321+ /**
4322+ * Sets the designated parameter to a <code>Reader</code> object. The
4323+ * <code>Reader</code> reads the data till end-of-file is reached. The
4324+ * driver does the necessary conversion from Java character format to
4325+ * the national character set in the database.
4326+
4327+ * <P><B>Note:</B> This stream object can either be a standard
4328+ * Java stream object or your own subclass that implements the
4329+ * standard interface.
4330+ * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
4331+ * it might be more efficient to use a version of
4332+ * <code>setNCharacterStream</code> which takes a length parameter.
4333+ *
4334+ * @param parameterName the name of the parameter
4335+ * @param value the parameter value
4336+ * @throws SQLException if the driver does not support national
4337+ * character sets; if the driver can detect that a data conversion
4338+ * error could occur ; if a database access error occurs; or
4339+ * this method is called on a closed <code>CallableStatement</code>
4340+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
4341+ * @since 1.6
4342+ */
4343+ public void setNCharacterStream(String parameterName, Reader value) throws SQLException{
4344+ throw new SQLFeatureNotSupportedException("Feature not supported");
4345+ }
4346+
4347+
4348+ /**
4349+ * Sets the designated parameter to a <code>java.sql.NClob</code> object. The object
4350+ * implements the <code>java.sql.NClob</code> interface. This <code>NClob</code>
4351+ * object maps to a SQL <code>NCLOB</code>.
4352+ * @param parameterName the name of the column to be set
4353+ * @param value the parameter value
4354+ * @throws SQLException if the driver does not support national
4355+ * character sets; if the driver can detect that a data conversion
4356+ * error could occur; or if a database access error occurs
4357+ * @since 1.6
4358+ */
4359+ public void setNClob(String parameterName, NClob value) throws SQLException{
4360+ throw new SQLFeatureNotSupportedException("Feature not supported");
4361+ }
4362+
4363+
4364+ /**
4365+ * Sets the designated parameter to a <code>Reader</code> object. The <code>reader</code> must contain * the number
4366+ * of characters specified by length otherwise a <code>SQLException</code> will be
4367+ * generated when the <code>CallableStatement</code> is executed.
4368+ * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
4369+ * because it informs the driver that the parameter value should be sent to
4370+ * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the
4371+ * driver may have to do extra work to determine whether the parameter
4372+ * data should be send to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
4373+ *
4374+ * @param parameterName the name of the parameter to be set
4375+ * @param reader An object that contains the data to set the parameter value to.
4376+ * @param length the number of characters in the parameter data.
4377+ * @throws SQLException if parameterIndex does not correspond to a parameter
4378+ * marker in the SQL statement; if the length specified is less than zero;
4379+ * if the driver does not support national
4380+ * character sets; if the driver can detect that a data conversion
4381+ * error could occur; if a database access error occurs or
4382+ * this method is called on a closed <code>CallableStatement</code>
4383+ * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
4384+ * this method
4385+ * @since 1.6
4386+ */
4387+ public void setNClob(String parameterName, Reader reader, long length)
4388+ throws SQLException{
4389+ throw new SQLFeatureNotSupportedException("Feature not supported");
4390+ }
4391+
4392+
4393+ /**
4394+ * Sets the designated parameter to a <code>Reader</code> object.
4395+ * This method differs from the <code>setCharacterStream (int, Reader)</code> method
4396+ * because it informs the driver that the parameter value should be sent to
4397+ * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the
4398+ * driver may have to do extra work to determine whether the parameter
4399+ * data should be send to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
4400+ * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
4401+ * it might be more efficient to use a version of
4402+ * <code>setNClob</code> which takes a length parameter.
4403+ *
4404+ * @param parameterName the name of the parameter
4405+ * @param reader An object that contains the data to set the parameter value to.
4406+ * @throws SQLException if the driver does not support national character sets;
4407+ * if the driver can detect that a data conversion
4408+ * error could occur; if a database access error occurs or
4409+ * this method is called on a closed <code>CallableStatement</code>
4410+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
4411+ *
4412+ * @since 1.6
4413+ */
4414+ public void setNClob(String parameterName, Reader reader)
4415+ throws SQLException{
4416+ throw new SQLFeatureNotSupportedException("Feature not supported");
4417+ }
4418+
4419+
4420+ /**
4421+ * Sets the designated parameter to a <code>Reader</code> object. The reader must contain the number
4422+ * of characters specified by length otherwise a <code>SQLException</code> will be
4423+ * generated when the <code>PreparedStatement</code> is executed.
4424+ * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
4425+ * because it informs the driver that the parameter value should be sent to
4426+ * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the
4427+ * driver may have to do extra work to determine whether the parameter
4428+ * data should be sent to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
4429+ * @param parameterIndex index of the first parameter is 1, the second is 2, ...
4430+ * @param reader An object that contains the data to set the parameter value to.
4431+ * @param length the number of characters in the parameter data.
4432+ * @throws SQLException if parameterIndex does not correspond to a parameter
4433+ * marker in the SQL statement; if the length specified is less than zero;
4434+ * if the driver does not support national character sets;
4435+ * if the driver can detect that a data conversion
4436+ * error could occur; if a database access error occurs or
4437+ * this method is called on a closed <code>PreparedStatement</code>
4438+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
4439+ *
4440+ * @since 1.6
4441+ */
4442+ public void setNClob(int parameterIndex, Reader reader, long length)
4443+ throws SQLException{
4444+ throw new SQLFeatureNotSupportedException("Feature not supported");
4445+ }
4446+
4447+
4448+ /**
4449+ * Sets the designated parameter to a <code>java.sql.NClob</code> object. The driver converts this oa
4450+ * SQL <code>NCLOB</code> value when it sends it to the database.
4451+ * @param parameterIndex of the first parameter is 1, the second is 2, ...
4452+ * @param value the parameter value
4453+ * @throws SQLException if the driver does not support national
4454+ * character sets; if the driver can detect that a data conversion
4455+ * error could occur ; or if a database access error occurs
4456+ * @since 1.6
4457+ */
4458+ public void setNClob(int parameterIndex, NClob value) throws SQLException{
4459+ throw new SQLFeatureNotSupportedException("Feature not supported");
4460+ }
4461+
4462+
4463+ /**
4464+ * Sets the designated parameter to a <code>Reader</code> object.
4465+ * This method differs from the <code>setCharacterStream (int, Reader)</code> method
4466+ * because it informs the driver that the parameter value should be sent to
4467+ * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the
4468+ * driver may have to do extra work to determine whether the parameter
4469+ * data should be sent to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
4470+ * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
4471+ * it might be more efficient to use a version of
4472+ * <code>setNClob</code> which takes a length parameter.
4473+ *
4474+ * @param parameterIndex index of the first parameter is 1, the second is 2, ...
4475+ * @param reader An object that contains the data to set the parameter value to.
4476+ * @throws SQLException if parameterIndex does not correspond to a parameter
4477+ * marker in the SQL statement;
4478+ * if the driver does not support national character sets;
4479+ * if the driver can detect that a data conversion
4480+ * error could occur; if a database access error occurs or
4481+ * this method is called on a closed <code>PreparedStatement</code>
4482+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
4483+ *
4484+ * @since 1.6
4485+ */
4486+ public void setNClob(int parameterIndex, Reader reader)
4487+ throws SQLException{
4488+ throw new SQLFeatureNotSupportedException("Feature not supported");
4489+ }
4490+
4491+
4492+ /**
4493+ * Sets the designated parameter to the given <code>java.net.URL</code> value.
4494+ * The driver converts this to an SQL <code>DATALINK</code> value
4495+ * when it sends it to the database.
4496+ *
4497+ * @param parameterIndex the first parameter is 1, the second is 2, ...
4498+ * @param x the <code>java.net.URL</code> object to be set
4499+ * @exception SQLException if a database access error occurs or
4500+ * this method is called on a closed <code>PreparedStatement</code>
4501+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
4502+ * @since 1.4
4503+ */
4504+ public void setURL(int parameterIndex, java.net.URL x) throws SQLException{
4505+ throw new SQLFeatureNotSupportedException("Feature not supported");
4506+ }
4507+
4508+
4509+
4510+ static final long serialVersionUID = 4886719666485113312L;
4511+
4512+} //end class