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