1 /*
2 * Copyright 1996-2006 Sun Microsystems, Inc. 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. Sun designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22 * CA 95054 USA or visit www.sun.com if you need additional information or
23 * have any questions.
24 */
25
26 package java.sql;
27
28 import java.math.BigDecimal;
29 import java.util.Calendar;
30 import java.io.Reader;
31 import java.io.InputStream;
32
33 /**
34 * A table of data representing a database result set, which
35 * is usually generated by executing a statement that queries the database.
36 *
37 * <P>A <code>ResultSet</code> object maintains a cursor pointing
38 * to its current row of data. Initially the cursor is positioned
39 * before the first row. The <code>next</code> method moves the
40 * cursor to the next row, and because it returns <code>false</code>
41 * when there are no more rows in the <code>ResultSet</code> object,
42 * it can be used in a <code>while</code> loop to iterate through
43 * the result set.
44 * <P>
45 * A default <code>ResultSet</code> object is not updatable and
46 * has a cursor that moves forward only. Thus, you can
47 * iterate through it only once and only from the first row to the
48 * last row. It is possible to
49 * produce <code>ResultSet</code> objects that are scrollable and/or
50 * updatable. The following code fragment, in which <code>con</code>
51 * is a valid <code>Connection</code> object, illustrates how to make
52 * a result set that is scrollable and insensitive to updates by others, and
53 * that is updatable. See <code>ResultSet</code> fields for other
54 * options.
55 * <PRE>
56 *
57 * Statement stmt = con.createStatement(
58 * ResultSet.TYPE_SCROLL_INSENSITIVE,
59 * ResultSet.CONCUR_UPDATABLE);
60 * ResultSet rs = stmt.executeQuery("SELECT a, b FROM TABLE2");
61 * // rs will be scrollable, will not show changes made by others,
62 * // and will be updatable
63 *
64 * </PRE>
65 * The <code>ResultSet</code> interface provides
66 * <i>getter</i> methods (<code>getBoolean</code>, <code>getLong</code>, and so on)
67 * for retrieving column values from the current row.
68 * Values can be retrieved using either the index number of the
69 * column or the name of the column. In general, using the
70 * column index will be more efficient. Columns are numbered from 1.
71 * For maximum portability, result set columns within each row should be
72 * read in left-to-right order, and each column should be read only once.
73 *
74 * <P>For the getter methods, a JDBC driver attempts
75 * to convert the underlying data to the Java type specified in the
76 * getter method and returns a suitable Java value. The JDBC specification
77 * has a table showing the allowable mappings from SQL types to Java types
78 * that can be used by the <code>ResultSet</code> getter methods.
79 * <P>
80 * <P>Column names used as input to getter methods are case
81 * insensitive. When a getter method is called with
82 * a column name and several columns have the same name,
83 * the value of the first matching column will be returned.
84 * The column name option is
85 * designed to be used when column names are used in the SQL
86 * query that generated the result set.
87 * For columns that are NOT explicitly named in the query, it
88 * is best to use column numbers. If column names are used, the
89 * programmer should take care to guarantee that they uniquely refer to
90 * the intended columns, which can be assured with the SQL <i>AS</i> clause.
91 * <P>
92 * A set of updater methods were added to this interface
93 * in the JDBC 2.0 API (Java<sup><font size=-2>TM</font></sup> 2 SDK,
94 * Standard Edition, version 1.2). The comments regarding parameters
95 * to the getter methods also apply to parameters to the
96 * updater methods.
97 *<P>
98 * The updater methods may be used in two ways:
99 * <ol>
100 * <LI>to update a column value in the current row. In a scrollable
101 * <code>ResultSet</code> object, the cursor can be moved backwards
102 * and forwards, to an absolute position, or to a position
103 * relative to the current row.
104 * The following code fragment updates the <code>NAME</code> column
105 * in the fifth row of the <code>ResultSet</code> object
106 * <code>rs</code> and then uses the method <code>updateRow</code>
107 * to update the data source table from which <code>rs</code> was derived.
108 * <PRE>
109 *
110 * rs.absolute(5); // moves the cursor to the fifth row of rs
111 * rs.updateString("NAME", "AINSWORTH"); // updates the
112 * // <code>NAME</code> column of row 5 to be <code>AINSWORTH</code>
113 * rs.updateRow(); // updates the row in the data source
114 *
115 * </PRE>
116 * <LI>to insert column values into the insert row. An updatable
117 * <code>ResultSet</code> object has a special row associated with
118 * it that serves as a staging area for building a row to be inserted.
119 * The following code fragment moves the cursor to the insert row, builds
120 * a three-column row, and inserts it into <code>rs</code> and into
121 * the data source table using the method <code>insertRow</code>.
122 * <PRE>
123 *
124 * rs.moveToInsertRow(); // moves cursor to the insert row
125 * rs.updateString(1, "AINSWORTH"); // updates the
126 * // first column of the insert row to be <code>AINSWORTH</code>
127 * rs.updateInt(2,35); // updates the second column to be <code>35</code>
128 * rs.updateBoolean(3, true); // updates the third column to <code>true</code>
129 * rs.insertRow();
130 * rs.moveToCurrentRow();
131 *
132 * </PRE>
133 * </ol>
134 * <P>A <code>ResultSet</code> object is automatically closed when the
135 * <code>Statement</code> object that
136 * generated it is closed, re-executed, or used
137 * to retrieve the next result from a sequence of multiple results.
138 *
139 * <P>The number, types and properties of a <code>ResultSet</code>
140 * object's columns are provided by the <code>ResulSetMetaData</code>
141 * object returned by the <code>ResultSet.getMetaData</code> method.
142 *
143 * @see Statement#executeQuery
144 * @see Statement#getResultSet
145 * @see ResultSetMetaData
146 */
147
148 public interface ResultSet extends Wrapper {
149
150 /**
151 * Moves the cursor froward one row from its current position.
152 * A <code>ResultSet</code> cursor is initially positioned
153 * before the first row; the first call to the method
154 * <code>next</code> makes the first row the current row; the
155 * second call makes the second row the current row, and so on.
156 * <p>
157 * When a call to the <code>next</code> method returns <code>false</code>,
158 * the cursor is positioned after the last row. Any
159 * invocation of a <code>ResultSet</code> method which requires a
160 * current row will result in a <code>SQLException</code> being thrown.
161 * If the result set type is <code>TYPE_FORWARD_ONLY</code>, it is vendor specified
162 * whether their JDBC driver implementation will return <code>false</code> or
163 * throw an <code>SQLException</code> on a
164 * subsequent call to <code>next</code>.
165 *
166 * <P>If an input stream is open for the current row, a call
167 * to the method <code>next</code> will
168 * implicitly close it. A <code>ResultSet</code> object's
169 * warning chain is cleared when a new row is read.
170 *
171 * @return <code>true</code> if the new current row is valid;
172 * <code>false</code> if there are no more rows
173 * @exception SQLException if a database access error occurs or this method is
174 * called on a closed result set
175 */
176 boolean next() throws SQLException;
177
178
179 /**
180 * Releases this <code>ResultSet</code> object's database and
181 * JDBC resources immediately instead of waiting for
182 * this to happen when it is automatically closed.
183 *
184 * <P>The closing of a <code>ResultSet</code> object does <strong>not</strong> close the <code>Blob</code>,
185 * <code>Clob</code> or <code>NClob</code> objects created by the <code>ResultSet</code>. <code>Blob</code>,
186 * <code>Clob</code> or <code>NClob</code> objects remain valid for at least the duration of the
187 * transaction in which they are creataed, unless their <code>free</code> method is invoked.
188 *<p>
189 * When a <code>ResultSet</code> is closed, any <code>ResultSetMetaData</code>
190 * instances that were created by calling the <code>getMetaData</code>
191 * method remain accessible.
192 *
193 * <P><B>Note:</B> A <code>ResultSet</code> object
194 * is automatically closed by the
195 * <code>Statement</code> object that generated it when
196 * that <code>Statement</code> object is closed,
197 * re-executed, or is used to retrieve the next result from a
198 * sequence of multiple results.
199 *<p>
200 * Calling the method <code>close</code> on a <code>ResultSet</code>
201 * object that is already closed is a no-op.
202 * <P>
203 * <p>
204 *
205 * @exception SQLException if a database access error occurs
206 */
207 void close() throws SQLException;
208
209 /**
210 * Reports whether
211 * the last column read had a value of SQL <code>NULL</code>.
212 * Note that you must first call one of the getter methods
213 * on a column to try to read its value and then call
214 * the method <code>wasNull</code> to see if the value read was
215 * SQL <code>NULL</code>.
216 *
217 * @return <code>true</code> if the last column value read was SQL
218 * <code>NULL</code> and <code>false</code> otherwise
219 * @exception SQLException if a database access error occurs or this method is
220 * called on a closed result set
221 */
222 boolean wasNull() throws SQLException;
223
224 // Methods for accessing results by column index
225
226 /**
227 * Retrieves the value of the designated column in the current row
228 * of this <code>ResultSet</code> object as
229 * a <code>String</code> in the Java programming language.
230 *
231 * @param columnIndex the first column is 1, the second is 2, ...
232 * @return the column value; if the value is SQL <code>NULL</code>, the
233 * value returned is <code>null</code>
234 * @exception SQLException if the columnIndex is not valid;
235 * if a database access error occurs or this method is
236 * called on a closed result set
237 */
238 String getString(int columnIndex) throws SQLException;
239
240 /**
241 * Retrieves the value of the designated column in the current row
242 * of this <code>ResultSet</code> object as
243 * a <code>boolean</code> in the Java programming language.
244 *
245 * <P>If the designated column has a datatype of CHAR or VARCHAR
246 * and contains a "0" or has a datatype of BIT, TINYINT, SMALLINT, INTEGER or BIGINT
247 * and contains a 0, a value of <code>false</code> is returned. If the designated column has a datatype
248 * of CHAR or VARCHAR
249 * and contains a "1" or has a datatype of BIT, TINYINT, SMALLINT, INTEGER or BIGINT
250 * and contains a 1, a value of <code>true</code> is returned.
251 *
252 * @param columnIndex the first column is 1, the second is 2, ...
253 * @return the column value; if the value is SQL <code>NULL</code>, the
254 * value returned is <code>false</code>
255 * @exception SQLException if the columnIndex is not valid;
256 * if a database access error occurs or this method is
257 * called on a closed result set
258 */
259 boolean getBoolean(int columnIndex) throws SQLException;
260
261 /**
262 * Retrieves the value of the designated column in the current row
263 * of this <code>ResultSet</code> object as
264 * a <code>byte</code> in the Java programming language.
265 *
266 * @param columnIndex the first column is 1, the second is 2, ...
267 * @return the column value; if the value is SQL <code>NULL</code>, the
268 * value returned is <code>0</code>
269 * @exception SQLException if the columnIndex is not valid;
270 * if a database access error occurs or this method is
271 * called on a closed result set
272 */
273 byte getByte(int columnIndex) throws SQLException;
274
275 /**
276 * Retrieves the value of the designated column in the current row
277 * of this <code>ResultSet</code> object as
278 * a <code>short</code> in the Java programming language.
279 *
280 * @param columnIndex the first column is 1, the second is 2, ...
281 * @return the column value; if the value is SQL <code>NULL</code>, the
282 * value returned is <code>0</code>
283 * @exception SQLException if the columnIndex is not valid;
284 * if a database access error occurs or this method is
285 * called on a closed result set
286 */
287 short getShort(int columnIndex) throws SQLException;
288
289 /**
290 * Retrieves the value of the designated column in the current row
291 * of this <code>ResultSet</code> object as
292 * an <code>int</code> in the Java programming language.
293 *
294 * @param columnIndex the first column is 1, the second is 2, ...
295 * @return the column value; if the value is SQL <code>NULL</code>, the
296 * value returned is <code>0</code>
297 * @exception SQLException if the columnIndex is not valid;
298 * if a database access error occurs or this method is
299 * called on a closed result set
300 */
301 int getInt(int columnIndex) throws SQLException;
302
303 /**
304 * Retrieves the value of the designated column in the current row
305 * of this <code>ResultSet</code> object as
306 * a <code>long</code> in the Java programming language.
307 *
308 * @param columnIndex the first column is 1, the second is 2, ...
309 * @return the column value; if the value is SQL <code>NULL</code>, the
310 * value returned is <code>0</code>
311 * @exception SQLException if the columnIndex is not valid;
312 * if a database access error occurs or this method is
313 * called on a closed result set
314 */
315 long getLong(int columnIndex) throws SQLException;
316
317 /**
318 * Retrieves the value of the designated column in the current row
319 * of this <code>ResultSet</code> object as
320 * a <code>float</code> in the Java programming language.
321 *
322 * @param columnIndex the first column is 1, the second is 2, ...
323 * @return the column value; if the value is SQL <code>NULL</code>, the
324 * value returned is <code>0</code>
325 * @exception SQLException if the columnIndex is not valid;
326 * if a database access error occurs or this method is
327 * called on a closed result set
328 */
329 float getFloat(int columnIndex) throws SQLException;
330
331 /**
332 * Retrieves the value of the designated column in the current row
333 * of this <code>ResultSet</code> object as
334 * a <code>double</code> in the Java programming language.
335 *
336 * @param columnIndex the first column is 1, the second is 2, ...
337 * @return the column value; if the value is SQL <code>NULL</code>, the
338 * value returned is <code>0</code>
339 * @exception SQLException if the columnIndex is not valid;
340 * if a database access error occurs or this method is
341 * called on a closed result set
342 */
343 double getDouble(int columnIndex) throws SQLException;
344
345 /**
346 * Retrieves the value of the designated column in the current row
347 * of this <code>ResultSet</code> object as
348 * a <code>java.sql.BigDecimal</code> in the Java programming language.
349 *
350 * @param columnIndex the first column is 1, the second is 2, ...
351 * @param scale the number of digits to the right of the decimal point
352 * @return the column value; if the value is SQL <code>NULL</code>, the
353 * value returned is <code>null</code>
354 * @exception SQLException if the columnIndex is not valid;
355 * if a database access error occurs or this method is
356 * called on a closed result set
357 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
358 * this method
359 * @deprecated
360 */
361 BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException;
362
363 /**
364 * Retrieves the value of the designated column in the current row
365 * of this <code>ResultSet</code> object as
366 * a <code>byte</code> array in the Java programming language.
367 * The bytes represent the raw values returned by the driver.
368 *
369 * @param columnIndex the first column is 1, the second is 2, ...
370 * @return the column value; if the value is SQL <code>NULL</code>, the
371 * value returned is <code>null</code>
372 * @exception SQLException if the columnIndex is not valid;
373 * if a database access error occurs or this method is
374 * called on a closed result set
375 */
376 byte[] getBytes(int columnIndex) throws SQLException;
377
378 /**
379 * Retrieves the value of the designated column in the current row
380 * of this <code>ResultSet</code> object as
381 * a <code>java.sql.Date</code> object in the Java programming language.
382 *
383 * @param columnIndex the first column is 1, the second is 2, ...
384 * @return the column value; if the value is SQL <code>NULL</code>, the
385 * value returned is <code>null</code>
386 * @exception SQLException if the columnIndex is not valid;
387 * if a database access error occurs or this method is
388 * called on a closed result set
389 */
390 java.sql.Date getDate(int columnIndex) throws SQLException;
391
392 /**
393 * Retrieves the value of the designated column in the current row
394 * of this <code>ResultSet</code> object as
395 * a <code>java.sql.Time</code> object in the Java programming language.
396 *
397 * @param columnIndex the first column is 1, the second is 2, ...
398 * @return the column value; if the value is SQL <code>NULL</code>, the
399 * value returned is <code>null</code>
400 * @exception SQLException if the columnIndex is not valid;
401 * if a database access error occurs or this method is
402 * called on a closed result set
403 */
404 java.sql.Time getTime(int columnIndex) throws SQLException;
405
406 /**
407 * Retrieves the value of the designated column in the current row
408 * of this <code>ResultSet</code> object as
409 * a <code>java.sql.Timestamp</code> object in the Java programming language.
410 *
411 * @param columnIndex the first column is 1, the second is 2, ...
412 * @return the column value; if the value is SQL <code>NULL</code>, the
413 * value returned is <code>null</code>
414 * @exception SQLException if the columnIndex is not valid;
415 * if a database access error occurs or this method is
416 * called on a closed result set
417 */
418 java.sql.Timestamp getTimestamp(int columnIndex) throws SQLException;
419
420 /**
421 * Retrieves the value of the designated column in the current row
422 * of this <code>ResultSet</code> object as
423 * a stream of ASCII characters. The value can then be read in chunks from the
424 * stream. This method is particularly
425 * suitable for retrieving large <char>LONGVARCHAR</char> values.
426 * The JDBC driver will
427 * do any necessary conversion from the database format into ASCII.
428 *
429 * <P><B>Note:</B> All the data in the returned stream must be
430 * read prior to getting the value of any other column. The next
431 * call to a getter method implicitly closes the stream. Also, a
432 * stream may return <code>0</code> when the method
433 * <code>InputStream.available</code>
434 * is called whether there is data available or not.
435 *
436 * @param columnIndex the first column is 1, the second is 2, ...
437 * @return a Java input stream that delivers the database column value
438 * as a stream of one-byte ASCII characters;
439 * if the value is SQL <code>NULL</code>, the
440 * value returned is <code>null</code>
441 * @exception SQLException if the columnIndex is not valid;
442 * if a database access error occurs or this method is
443 * called on a closed result set
444 */
445 java.io.InputStream getAsciiStream(int columnIndex) throws SQLException;
446
447 /**
448 * Retrieves the value of the designated column in the current row
449 * of this <code>ResultSet</code> object as
450 * as a stream of two-byte 3 characters. The first byte is
451 * the high byte; the second byte is the low byte.
452 *
453 * The value can then be read in chunks from the
454 * stream. This method is particularly
455 * suitable for retrieving large <code>LONGVARCHAR</code>values. The
456 * JDBC driver will do any necessary conversion from the database
457 * format into Unicode.
458 *
459 * <P><B>Note:</B> All the data in the returned stream must be
460 * read prior to getting the value of any other column. The next
461 * call to a getter method implicitly closes the stream.
462 * Also, a stream may return <code>0</code> when the method
463 * <code>InputStream.available</code>
464 * is called, whether there is data available or not.
465 *
466 * @param columnIndex the first column is 1, the second is 2, ...
467 * @return a Java input stream that delivers the database column value
468 * as a stream of two-byte Unicode characters;
469 * if the value is SQL <code>NULL</code>, the value returned is
470 * <code>null</code>
471 *
472 * @exception SQLException if the columnIndex is not valid;
473 * if a database access error occurs or this method is
474 * called on a closed result set
475 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
476 * this method
477 * @deprecated use <code>getCharacterStream</code> in place of
478 * <code>getUnicodeStream</code>
479 */
480 java.io.InputStream getUnicodeStream(int columnIndex) throws SQLException;
481
482 /**
483 * Retrieves the value of the designated column in the current row
484 * of this <code>ResultSet</code> object as a stream of
485 * uninterpreted bytes. The value can then be read in chunks from the
486 * stream. This method is particularly
487 * suitable for retrieving large <code>LONGVARBINARY</code> values.
488 *
489 * <P><B>Note:</B> All the data in the returned stream must be
490 * read prior to getting the value of any other column. The next
491 * call to a getter method implicitly closes the stream. Also, a
492 * stream may return <code>0</code> when the method
493 * <code>InputStream.available</code>
494 * is called whether there is data available or not.
495 *
496 * @param columnIndex the first column is 1, the second is 2, ...
497 * @return a Java input stream that delivers the database column value
498 * as a stream of uninterpreted bytes;
499 * if the value is SQL <code>NULL</code>, the value returned is
500 * <code>null</code>
501 * @exception SQLException if the columnIndex is not valid;
502 * if a database access error occurs or this method is
503 * called on a closed result set
504 */
505 java.io.InputStream getBinaryStream(int columnIndex)
506 throws SQLException;
507
508
509 // Methods for accessing results by column label
510
511 /**
512 * Retrieves the value of the designated column in the current row
513 * of this <code>ResultSet</code> object as
514 * a <code>String</code> in the Java programming language.
515 *
516 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
517 * @return the column value; if the value is SQL <code>NULL</code>, the
518 * value returned is <code>null</code>
519 * @exception SQLException if the columnLabel is not valid;
520 * if a database access error occurs or this method is
521 * called on a closed result set
522 */
523 String getString(String columnLabel) throws SQLException;
524
525 /**
526 * Retrieves the value of the designated column in the current row
527 * of this <code>ResultSet</code> object as
528 * a <code>boolean</code> in the Java programming language.
529 *
530 * <P>If the designated column has a datatype of CHAR or VARCHAR
531 * and contains a "0" or has a datatype of BIT, TINYINT, SMALLINT, INTEGER or BIGINT
532 * and contains a 0, a value of <code>false</code> is returned. If the designated column has a datatype
533 * of CHAR or VARCHAR
534 * and contains a "1" or has a datatype of BIT, TINYINT, SMALLINT, INTEGER or BIGINT
535 * and contains a 1, a value of <code>true</code> is returned.
536 *
537 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
538 * @return the column value; if the value is SQL <code>NULL</code>, the
539 * value returned is <code>false</code>
540 * @exception SQLException if the columnLabel is not valid;
541 * if a database access error occurs or this method is
542 * called on a closed result set
543 */
544 boolean getBoolean(String columnLabel) throws SQLException;
545
546 /**
547 * Retrieves the value of the designated column in the current row
548 * of this <code>ResultSet</code> object as
549 * a <code>byte</code> in the Java programming language.
550 *
551 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
552 * @return the column value; if the value is SQL <code>NULL</code>, the
553 * value returned is <code>0</code>
554 * @exception SQLException if the columnLabel is not valid;
555 * if a database access error occurs or this method is
556 * called on a closed result set
557 */
558 byte getByte(String columnLabel) throws SQLException;
559
560 /**
561 * Retrieves the value of the designated column in the current row
562 * of this <code>ResultSet</code> object as
563 * a <code>short</code> in the Java programming language.
564 *
565 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
566 * @return the column value; if the value is SQL <code>NULL</code>, the
567 * value returned is <code>0</code>
568 * @exception SQLException if the columnLabel is not valid;
569 * if a database access error occurs or this method is
570 * called on a closed result set
571 */
572 short getShort(String columnLabel) throws SQLException;
573
574 /**
575 * Retrieves the value of the designated column in the current row
576 * of this <code>ResultSet</code> object as
577 * an <code>int</code> in the Java programming language.
578 *
579 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
580 * @return the column value; if the value is SQL <code>NULL</code>, the
581 * value returned is <code>0</code>
582 * @exception SQLException if the columnLabel is not valid;
583 * if a database access error occurs or this method is
584 * called on a closed result set
585 */
586 int getInt(String columnLabel) throws SQLException;
587
588 /**
589 * Retrieves the value of the designated column in the current row
590 * of this <code>ResultSet</code> object as
591 * a <code>long</code> in the Java programming language.
592 *
593 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
594 * @return the column value; if the value is SQL <code>NULL</code>, the
595 * value returned is <code>0</code>
596 * @exception SQLException if the columnLabel is not valid;
597 * if a database access error occurs or this method is
598 * called on a closed result set
599 */
600 long getLong(String columnLabel) throws SQLException;
601
602 /**
603 * Retrieves the value of the designated column in the current row
604 * of this <code>ResultSet</code> object as
605 * a <code>float</code> in the Java programming language.
606 *
607 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
608 * @return the column value; if the value is SQL <code>NULL</code>, the
609 * value returned is <code>0</code>
610 * @exception SQLException if the columnLabel is not valid;
611 * if a database access error occurs or this method is
612 * called on a closed result set
613 */
614 float getFloat(String columnLabel) throws SQLException;
615
616 /**
617 * Retrieves the value of the designated column in the current row
618 * of this <code>ResultSet</code> object as
619 * a <code>double</code> in the Java programming language.
620 *
621 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
622 * @return the column value; if the value is SQL <code>NULL</code>, the
623 * value returned is <code>0</code>
624 * @exception SQLException if the columnLabel is not valid;
625 * if a database access error occurs or this method is
626 * called on a closed result set
627 */
628 double getDouble(String columnLabel) throws SQLException;
629
630 /**
631 * Retrieves the value of the designated column in the current row
632 * of this <code>ResultSet</code> object as
633 * a <code>java.math.BigDecimal</code> in the Java programming language.
634 *
635 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
636 * @param scale the number of digits to the right of the decimal point
637 * @return the column value; if the value is SQL <code>NULL</code>, the
638 * value returned is <code>null</code>
639 * @exception SQLException if the columnLabel is not valid;
640 * if a database access error occurs or this method is
641 * called on a closed result set
642 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
643 * this method
644 * @deprecated
645 */
646 BigDecimal getBigDecimal(String columnLabel, int scale) throws SQLException;
647
648 /**
649 * Retrieves the value of the designated column in the current row
650 * of this <code>ResultSet</code> object as
651 * a <code>byte</code> array in the Java programming language.
652 * The bytes represent the raw values returned by the driver.
653 *
654 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
655 * @return the column value; if the value is SQL <code>NULL</code>, the
656 * value returned is <code>null</code>
657 * @exception SQLException if the columnLabel is not valid;
658 * if a database access error occurs or this method is
659 * called on a closed result set
660 */
661 byte[] getBytes(String columnLabel) throws SQLException;
662
663 /**
664 * Retrieves the value of the designated column in the current row
665 * of this <code>ResultSet</code> object as
666 * a <code>java.sql.Date</code> object in the Java programming language.
667 *
668 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
669 * @return the column value; if the value is SQL <code>NULL</code>, the
670 * value returned is <code>null</code>
671 * @exception SQLException if the columnLabel is not valid;
672 * if a database access error occurs or this method is
673 * called on a closed result set
674 */
675 java.sql.Date getDate(String columnLabel) throws SQLException;
676
677 /**
678 * Retrieves the value of the designated column in the current row
679 * of this <code>ResultSet</code> object as
680 * a <code>java.sql.Time</code> object in the Java programming language.
681 *
682 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
683 * @return the column value;
684 * if the value is SQL <code>NULL</code>,
685 * the value returned is <code>null</code>
686 * @exception SQLException if the columnLabel is not valid;
687 * if a database access error occurs or this method is
688 * called on a closed result set
689 */
690 java.sql.Time getTime(String columnLabel) throws SQLException;
691
692 /**
693 * Retrieves the value of the designated column in the current row
694 * of this <code>ResultSet</code> object as
695 * a <code>java.sql.Timestamp</code> object in the Java programming language.
696 *
697 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
698 * @return the column value; if the value is SQL <code>NULL</code>, the
699 * value returned is <code>null</code>
700 * @exception SQLException if the columnLabel is not valid;
701 * if a database access error occurs or this method is
702 * called on a closed result set
703 */
704 java.sql.Timestamp getTimestamp(String columnLabel) throws SQLException;
705
706 /**
707 * Retrieves the value of the designated column in the current row
708 * of this <code>ResultSet</code> object as a stream of
709 * ASCII characters. The value can then be read in chunks from the
710 * stream. This method is particularly
711 * suitable for retrieving large <code>LONGVARCHAR</code> values.
712 * The JDBC driver will
713 * do any necessary conversion from the database format into ASCII.
714 *
715 * <P><B>Note:</B> All the data in the returned stream must be
716 * read prior to getting the value of any other column. The next
717 * call to a getter method implicitly closes the stream. Also, a
718 * stream may return <code>0</code> when the method <code>available</code>
719 * is called whether there is data available or not.
720 *
721 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
722 * @return a Java input stream that delivers the database column value
723 * as a stream of one-byte ASCII characters.
724 * If the value is SQL <code>NULL</code>,
725 * the value returned is <code>null</code>.
726 * @exception SQLException if the columnLabel is not valid;
727 * if a database access error occurs or this method is
728 * called on a closed result set
729 */
730 java.io.InputStream getAsciiStream(String columnLabel) throws SQLException;
731
732 /**
733 * Retrieves the value of the designated column in the current row
734 * of this <code>ResultSet</code> object as a stream of two-byte
735 * Unicode characters. The first byte is the high byte; the second
736 * byte is the low byte.
737 *
738 * The value can then be read in chunks from the
739 * stream. This method is particularly
740 * suitable for retrieving large <code>LONGVARCHAR</code> values.
741 * The JDBC technology-enabled driver will
742 * do any necessary conversion from the database format into Unicode.
743 *
744 * <P><B>Note:</B> All the data in the returned stream must be
745 * read prior to getting the value of any other column. The next
746 * call to a getter method implicitly closes the stream.
747 * Also, a stream may return <code>0</code> when the method
748 * <code>InputStream.available</code> is called, whether there
749 * is data available or not.
750 *
751 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
752 * @return a Java input stream that delivers the database column value
753 * as a stream of two-byte Unicode characters.
754 * If the value is SQL <code>NULL</code>, the value returned
755 * is <code>null</code>.
756 * @exception SQLException if the columnLabel is not valid;
757 * if a database access error occurs or this method is
758 * called on a closed result set
759 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
760 * this method
761 * @deprecated use <code>getCharacterStream</code> instead
762 */
763 java.io.InputStream getUnicodeStream(String columnLabel) throws SQLException;
764
765 /**
766 * Retrieves the value of the designated column in the current row
767 * of this <code>ResultSet</code> object as a stream of uninterpreted
768 * <code>byte</code>s.
769 * The value can then be read in chunks from the
770 * stream. This method is particularly
771 * suitable for retrieving large <code>LONGVARBINARY</code>
772 * values.
773 *
774 * <P><B>Note:</B> All the data in the returned stream must be
775 * read prior to getting the value of any other column. The next
776 * call to a getter method implicitly closes the stream. Also, a
777 * stream may return <code>0</code> when the method <code>available</code>
778 * is called whether there is data available or not.
779 *
780 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
781 * @return a Java input stream that delivers the database column value
782 * as a stream of uninterpreted bytes;
783 * if the value is SQL <code>NULL</code>, the result is <code>null</code>
784 * @exception SQLException if the columnLabel is not valid;
785 * if a database access error occurs or this method is
786 * called on a closed result set
787 */
788 java.io.InputStream getBinaryStream(String columnLabel)
789 throws SQLException;
790
791
792 // Advanced features:
793
794 /**
795 * Retrieves the first warning reported by calls on this
796 * <code>ResultSet</code> object.
797 * Subsequent warnings on this <code>ResultSet</code> object
798 * will be chained to the <code>SQLWarning</code> object that
799 * this method returns.
800 *
801 * <P>The warning chain is automatically cleared each time a new
802 * row is read. This method may not be called on a <code>ResultSet</code>
803 * object that has been closed; doing so will cause an
804 * <code>SQLException</code> to be thrown.
805 * <P>
806 * <B>Note:</B> This warning chain only covers warnings caused
807 * by <code>ResultSet</code> methods. Any warning caused by
808 * <code>Statement</code> methods
809 * (such as reading OUT parameters) will be chained on the
810 * <code>Statement</code> object.
811 *
812 * @return the first <code>SQLWarning</code> object reported or
813 * <code>null</code> if there are none
814 * @exception SQLException if a database access error occurs or this method is
815 * called on a closed result set
816 */
817 SQLWarning getWarnings() throws SQLException;
818
819 /**
820 * Clears all warnings reported on this <code>ResultSet</code> object.
821 * After this method is called, the method <code>getWarnings</code>
822 * returns <code>null</code> until a new warning is
823 * reported for this <code>ResultSet</code> object.
824 *
825 * @exception SQLException if a database access error occurs or this method is
826 * called on a closed result set
827 */
828 void clearWarnings() throws SQLException;
829
830 /**
831 * Retrieves the name of the SQL cursor used by this <code>ResultSet</code>
832 * object.
833 *
834 * <P>In SQL, a result table is retrieved through a cursor that is
835 * named. The current row of a result set can be updated or deleted
836 * using a positioned update/delete statement that references the
837 * cursor name. To insure that the cursor has the proper isolation
838 * level to support update, the cursor's <code>SELECT</code> statement
839 * should be of the form <code>SELECT FOR UPDATE</code>. If
840 * <code>FOR UPDATE</code> is omitted, the positioned updates may fail.
841 *
842 * <P>The JDBC API supports this SQL feature by providing the name of the
843 * SQL cursor used by a <code>ResultSet</code> object.
844 * The current row of a <code>ResultSet</code> object
845 * is also the current row of this SQL cursor.
846 *
847 * @return the SQL name for this <code>ResultSet</code> object's cursor
848 * @exception SQLException if a database access error occurs or this method is called on a closed result set
849 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
850 * this method
851 */
852 String getCursorName() throws SQLException;
853
854 /**
855 * Retrieves the number, types and properties of
856 * this <code>ResultSet</code> object's columns.
857 *
858 * @return the description of this <code>ResultSet</code> object's columns
859 * @exception SQLException if a database access error occurs or this method is
860 * called on a closed result set
861 */
862 ResultSetMetaData getMetaData() throws SQLException;
863
864 /**
865 * <p>Gets the value of the designated column in the current row
866 * of this <code>ResultSet</code> object as
867 * an <code>Object</code> in the Java programming language.
868 *
869 * <p>This method will return the value of the given column as a
870 * Java object. The type of the Java object will be the default
871 * Java object type corresponding to the column's SQL type,
872 * following the mapping for built-in types specified in the JDBC
873 * specification. If the value is an SQL <code>NULL</code>,
874 * the driver returns a Java <code>null</code>.
875 *
876 * <p>This method may also be used to read database-specific
877 * abstract data types.
878 *
879 * In the JDBC 2.0 API, the behavior of method
880 * <code>getObject</code> is extended to materialize
881 * data of SQL user-defined types.
882 * <p>
883 * If <code>Connection.getTypeMap</code> does not throw a
884 * <code>SQLFeatureNotSupportedException</code>,
885 * then when a column contains a structured or distinct value,
886 * the behavior of this method is as
887 * if it were a call to: <code>getObject(columnIndex,
888 * this.getStatement().getConnection().getTypeMap())</code>.
889 *
890 * If <code>Connection.getTypeMap</code> does throw a
891 * <code>SQLFeatureNotSupportedException</code>,
892 * then structured values are not supported, and distinct values
893 * are mapped to the default Java class as determined by the
894 * underlying SQL type of the DISTINCT type.
895 *
896 * @param columnIndex the first column is 1, the second is 2, ...
897 * @return a <code>java.lang.Object</code> holding the column value
898 * @exception SQLException if the columnIndex is not valid;
899 * if a database access error occurs or this method is
900 * called on a closed result set
901 */
902 Object getObject(int columnIndex) throws SQLException;
903
904 /**
905 * <p>Gets the value of the designated column in the current row
906 * of this <code>ResultSet</code> object as
907 * an <code>Object</code> in the Java programming language.
908 *
909 * <p>This method will return the value of the given column as a
910 * Java object. The type of the Java object will be the default
911 * Java object type corresponding to the column's SQL type,
912 * following the mapping for built-in types specified in the JDBC
913 * specification. If the value is an SQL <code>NULL</code>,
914 * the driver returns a Java <code>null</code>.
915 * <P>
916 * This method may also be used to read database-specific
917 * abstract data types.
918 * <P>
919 * In the JDBC 2.0 API, the behavior of the method
920 * <code>getObject</code> is extended to materialize
921 * data of SQL user-defined types. When a column contains
922 * a structured or distinct value, the behavior of this method is as
923 * if it were a call to: <code>getObject(columnIndex,
924 * this.getStatement().getConnection().getTypeMap())</code>.
925 *
926 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
927 * @return a <code>java.lang.Object</code> holding the column value
928 * @exception SQLException if the columnLabel is not valid;
929 * if a database access error occurs or this method is
930 * called on a closed result set
931 */
932 Object getObject(String columnLabel) throws SQLException;
933
934 //----------------------------------------------------------------
935
936 /**
937 * Maps the given <code>ResultSet</code> column label to its
938 * <code>ResultSet</code> column index.
939 *
940 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
941 * @return the column index of the given column name
942 * @exception SQLException if the <code>ResultSet</code> object
943 * does not contain a column labeled <code>columnLabel</code>, a database access error occurs
944 * or this method is called on a closed result set
945 */
946 int findColumn(String columnLabel) throws SQLException;
947
948
949 //--------------------------JDBC 2.0-----------------------------------
950
951 //---------------------------------------------------------------------
952 // Getters and Setters
953 //---------------------------------------------------------------------
954
955 /**
956 * Retrieves the value of the designated column in the current row
957 * of this <code>ResultSet</code> object as a
958 * <code>java.io.Reader</code> object.
959 * @return a <code>java.io.Reader</code> object that contains the column
960 * value; if the value is SQL <code>NULL</code>, the value returned is
961 * <code>null</code> in the Java programming language.
962 * @param columnIndex the first column is 1, the second is 2, ...
963 * @exception SQLException if the columnIndex is not valid;
964 * if a database access error occurs or this method is
965 * called on a closed result set
966 * @since 1.2
967 */
968 java.io.Reader getCharacterStream(int columnIndex) throws SQLException;
969
970 /**
971 * Retrieves the value of the designated column in the current row
972 * of this <code>ResultSet</code> object as a
973 * <code>java.io.Reader</code> object.
974 *
975 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
976 * @return a <code>java.io.Reader</code> object that contains the column
977 * value; if the value is SQL <code>NULL</code>, the value returned is
978 * <code>null</code> in the Java programming language
979 * @exception SQLException if the columnLabel is not valid;
980 * if a database access error occurs or this method is
981 * called on a closed result set
982 * @since 1.2
983 */
984 java.io.Reader getCharacterStream(String columnLabel) throws SQLException;
985
986 /**
987 * Retrieves the value of the designated column in the current row
988 * of this <code>ResultSet</code> object as a
989 * <code>java.math.BigDecimal</code> with full precision.
990 *
991 * @param columnIndex the first column is 1, the second is 2, ...
992 * @return the column value (full precision);
993 * if the value is SQL <code>NULL</code>, the value returned is
994 * <code>null</code> in the Java programming language.
995 * @exception SQLException if the columnIndex is not valid;
996 * if a database access error occurs or this method is
997 * called on a closed result set
998 * @since 1.2
999 */
1000 BigDecimal getBigDecimal(int columnIndex) throws SQLException;
1001
1002 /**
1003 * Retrieves the value of the designated column in the current row
1004 * of this <code>ResultSet</code> object as a
1005 * <code>java.math.BigDecimal</code> with full precision.
1006 *
1007 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
1008 * @return the column value (full precision);
1009 * if the value is SQL <code>NULL</code>, the value returned is
1010 * <code>null</code> in the Java programming language.
1011 * @exception SQLException if the columnLabel is not valid;
1012 * if a database access error occurs or this method is
1013 * called on a closed result set
1014 * @since 1.2
1015 *
1016 */
1017 BigDecimal getBigDecimal(String columnLabel) throws SQLException;
1018
1019 //---------------------------------------------------------------------
1020 // Traversal/Positioning
1021 //---------------------------------------------------------------------
1022
1023 /**
1024 * Retrieves whether the cursor is before the first row in
1025 * this <code>ResultSet</code> object.
1026 * <p>
1027 * <strong>Note:</strong>Support for the <code>isBeforeFirst</code> method
1028 * is optional for <code>ResultSet</code>s with a result
1029 * set type of <code>TYPE_FORWARD_ONLY</code>
1030 *
1031 * @return <code>true</code> if the cursor is before the first row;
1032 * <code>false</code> if the cursor is at any other position or the
1033 * result set contains no rows
1034 * @exception SQLException if a database access error occurs or this method is
1035 * called on a closed result set
1036 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1037 * this method
1038 * @since 1.2
1039 */
1040 boolean isBeforeFirst() throws SQLException;
1041
1042 /**
1043 * Retrieves whether the cursor is after the last row in
1044 * this <code>ResultSet</code> object.
1045 * <p>
1046 * <strong>Note:</strong>Support for the <code>isAfterLast</code> method
1047 * is optional for <code>ResultSet</code>s with a result
1048 * set type of <code>TYPE_FORWARD_ONLY</code>
1049 *
1050 * @return <code>true</code> if the cursor is after the last row;
1051 * <code>false</code> if the cursor is at any other position or the
1052 * result set contains no rows
1053 * @exception SQLException if a database access error occurs or this method is
1054 * called on a closed result set
1055 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1056 * this method
1057 * @since 1.2
1058 */
1059 boolean isAfterLast() throws SQLException;
1060
1061 /**
1062 * Retrieves whether the cursor is on the first row of
1063 * this <code>ResultSet</code> object.
1064 * <p>
1065 * <strong>Note:</strong>Support for the <code>isFirst</code> method
1066 * is optional for <code>ResultSet</code>s with a result
1067 * set type of <code>TYPE_FORWARD_ONLY</code>
1068 *
1069 * @return <code>true</code> if the cursor is on the first row;
1070 * <code>false</code> otherwise
1071 * @exception SQLException if a database access error occurs or this method is
1072 * called on a closed result set
1073 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1074 * this method
1075 * @since 1.2
1076 */
1077 boolean isFirst() throws SQLException;
1078
1079 /**
1080 * Retrieves whether the cursor is on the last row of
1081 * this <code>ResultSet</code> object.
1082 * <strong>Note:</strong> Calling the method <code>isLast</code> may be expensive
1083 * because the JDBC driver
1084 * might need to fetch ahead one row in order to determine
1085 * whether the current row is the last row in the result set.
1086 * <p>
1087 * <strong>Note:</strong> Support for the <code>isLast</code> method
1088 * is optional for <code>ResultSet</code>s with a result
1089 * set type of <code>TYPE_FORWARD_ONLY</code>
1090 * @return <code>true</code> if the cursor is on the last row;
1091 * <code>false</code> otherwise
1092 * @exception SQLException if a database access error occurs or this method is
1093 * called on a closed result set
1094 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1095 * this method
1096 * @since 1.2
1097 */
1098 boolean isLast() throws SQLException;
1099
1100 /**
1101 * Moves the cursor to the front of
1102 * this <code>ResultSet</code> object, just before the
1103 * first row. This method has no effect if the result set contains no rows.
1104 *
1105 * @exception SQLException if a database access error
1106 * occurs; this method is called on a closed result set or the
1107 * result set type is <code>TYPE_FORWARD_ONLY</code>
1108 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1109 * this method
1110 * @since 1.2
1111 */
1112 void beforeFirst() throws SQLException;
1113
1114 /**
1115 * Moves the cursor to the end of
1116 * this <code>ResultSet</code> object, just after the
1117 * last row. This method has no effect if the result set contains no rows.
1118 * @exception SQLException if a database access error
1119 * occurs; this method is called on a closed result set
1120 * or the result set type is <code>TYPE_FORWARD_ONLY</code>
1121 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1122 * this method
1123 * @since 1.2
1124 */
1125 void afterLast() throws SQLException;
1126
1127 /**
1128 * Moves the cursor to the first row in
1129 * this <code>ResultSet</code> object.
1130 *
1131 * @return <code>true</code> if the cursor is on a valid row;
1132 * <code>false</code> if there are no rows in the result set
1133 * @exception SQLException if a database access error
1134 * occurs; this method is called on a closed result set
1135 * or the result set type is <code>TYPE_FORWARD_ONLY</code>
1136 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1137 * this method
1138 * @since 1.2
1139 */
1140 boolean first() throws SQLException;
1141
1142 /**
1143 * Moves the cursor to the last row in
1144 * this <code>ResultSet</code> object.
1145 *
1146 * @return <code>true</code> if the cursor is on a valid row;
1147 * <code>false</code> if there are no rows in the result set
1148 * @exception SQLException if a database access error
1149 * occurs; this method is called on a closed result set
1150 * or the result set type is <code>TYPE_FORWARD_ONLY</code>
1151 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1152 * this method
1153 * @since 1.2
1154 */
1155 boolean last() throws SQLException;
1156
1157 /**
1158 * Retrieves the current row number. The first row is number 1, the
1159 * second number 2, and so on.
1160 * <p>
1161 * <strong>Note:</strong>Support for the <code>getRow</code> method
1162 * is optional for <code>ResultSet</code>s with a result
1163 * set type of <code>TYPE_FORWARD_ONLY</code>
1164 *
1165 * @return the current row number; <code>0</code> if there is no current row
1166 * @exception SQLException if a database access error occurs
1167 * or this method is called on a closed result set
1168 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1169 * this method
1170 * @since 1.2
1171 */
1172 int getRow() throws SQLException;
1173
1174 /**
1175 * Moves the cursor to the given row number in
1176 * this <code>ResultSet</code> object.
1177 *
1178 * <p>If the row number is positive, the cursor moves to
1179 * the given row number with respect to the
1180 * beginning of the result set. The first row is row 1, the second
1181 * is row 2, and so on.
1182 *
1183 * <p>If the given row number is negative, the cursor moves to
1184 * an absolute row position with respect to
1185 * the end of the result set. For example, calling the method
1186 * <code>absolute(-1)</code> positions the
1187 * cursor on the last row; calling the method <code>absolute(-2)</code>
1188 * moves the cursor to the next-to-last row, and so on.
1189 *
1190 * <p>An attempt to position the cursor beyond the first/last row in
1191 * the result set leaves the cursor before the first row or after
1192 * the last row.
1193 *
1194 * <p><B>Note:</B> Calling <code>absolute(1)</code> is the same
1195 * as calling <code>first()</code>. Calling <code>absolute(-1)</code>
1196 * is the same as calling <code>last()</code>.
1197 *
1198 * @param row the number of the row to which the cursor should move.
1199 * A positive number indicates the row number counting from the
1200 * beginning of the result set; a negative number indicates the
1201 * row number counting from the end of the result set
1202 * @return <code>true</code> if the cursor is moved to a position in this
1203 * <code>ResultSet</code> object;
1204 * <code>false</code> if the cursor is before the first row or after the
1205 * last row
1206 * @exception SQLException if a database access error
1207 * occurs; this method is called on a closed result set
1208 * or the result set type is <code>TYPE_FORWARD_ONLY</code>
1209 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1210 * this method
1211 * @since 1.2
1212 */
1213 boolean absolute( int row ) throws SQLException;
1214
1215 /**
1216 * Moves the cursor a relative number of rows, either positive or negative.
1217 * Attempting to move beyond the first/last row in the
1218 * result set positions the cursor before/after the
1219 * the first/last row. Calling <code>relative(0)</code> is valid, but does
1220 * not change the cursor position.
1221 *
1222 * <p>Note: Calling the method <code>relative(1)</code>
1223 * is identical to calling the method <code>next()</code> and
1224 * calling the method <code>relative(-1)</code> is identical
1225 * to calling the method <code>previous()</code>.
1226 *
1227 * @param rows an <code>int</code> specifying the number of rows to
1228 * move from the current row; a positive number moves the cursor
1229 * forward; a negative number moves the cursor backward
1230 * @return <code>true</code> if the cursor is on a row;
1231 * <code>false</code> otherwise
1232 * @exception SQLException if a database access error occurs; this method
1233 * is called on a closed result set or the result set type is
1234 * <code>TYPE_FORWARD_ONLY</code>
1235 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1236 * this method
1237 * @since 1.2
1238 */
1239 boolean relative( int rows ) throws SQLException;
1240
1241 /**
1242 * Moves the cursor to the previous row in this
1243 * <code>ResultSet</code> object.
1244 *<p>
1245 * When a call to the <code>previous</code> method returns <code>false</code>,
1246 * the cursor is positioned before the first row. Any invocation of a
1247 * <code>ResultSet</code> method which requires a current row will result in a
1248 * <code>SQLException</code> being thrown.
1249 *<p>
1250 * If an input stream is open for the current row, a call to the method
1251 * <code>previous</code> will implicitly close it. A <code>ResultSet</code>
1252 * object's warning change is cleared when a new row is read.
1253 *<p>
1254 *
1255 * @return <code>true</code> if the cursor is now positioned on a valid row;
1256 * <code>false</code> if the cursor is positioned before the first row
1257 * @exception SQLException if a database access error
1258 * occurs; this method is called on a closed result set
1259 * or the result set type is <code>TYPE_FORWARD_ONLY</code>
1260 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1261 * this method
1262 * @since 1.2
1263 */
1264 boolean previous() throws SQLException;
1265
1266 //---------------------------------------------------------------------
1267 // Properties
1268 //---------------------------------------------------------------------
1269
1270 /**
1271 * The constant indicating that the rows in a result set will be
1272 * processed in a forward direction; first-to-last.
1273 * This constant is used by the method <code>setFetchDirection</code>
1274 * as a hint to the driver, which the driver may ignore.
1275 * @since 1.2
1276 */
1277 int FETCH_FORWARD = 1000;
1278
1279 /**
1280 * The constant indicating that the rows in a result set will be
1281 * processed in a reverse direction; last-to-first.
1282 * This constant is used by the method <code>setFetchDirection</code>
1283 * as a hint to the driver, which the driver may ignore.
1284 * @since 1.2
1285 */
1286 int FETCH_REVERSE = 1001;
1287
1288 /**
1289 * The constant indicating that the order in which rows in a
1290 * result set will be processed is unknown.
1291 * This constant is used by the method <code>setFetchDirection</code>
1292 * as a hint to the driver, which the driver may ignore.
1293 */
1294 int FETCH_UNKNOWN = 1002;
1295
1296 /**
1297 * Gives a hint as to the direction in which the rows in this
1298 * <code>ResultSet</code> object will be processed.
1299 * The initial value is determined by the
1300 * <code>Statement</code> object
1301 * that produced this <code>ResultSet</code> object.
1302 * The fetch direction may be changed at any time.
1303 *
1304 * @param direction an <code>int</code> specifying the suggested
1305 * fetch direction; one of <code>ResultSet.FETCH_FORWARD</code>,
1306 * <code>ResultSet.FETCH_REVERSE</code>, or
1307 * <code>ResultSet.FETCH_UNKNOWN</code>
1308 * @exception SQLException if a database access error occurs; this
1309 * method is called on a closed result set or
1310 * the result set type is <code>TYPE_FORWARD_ONLY</code> and the fetch
1311 * direction is not <code>FETCH_FORWARD</code>
1312 * @since 1.2
1313 * @see Statement#setFetchDirection
1314 * @see #getFetchDirection
1315 */
1316 void setFetchDirection(int direction) throws SQLException;
1317
1318 /**
1319 * Retrieves the fetch direction for this
1320 * <code>ResultSet</code> object.
1321 *
1322 * @return the current fetch direction for this <code>ResultSet</code> object
1323 * @exception SQLException if a database access error occurs
1324 * or this method is called on a closed result set
1325 * @since 1.2
1326 * @see #setFetchDirection
1327 */
1328 int getFetchDirection() throws SQLException;
1329
1330 /**
1331 * Gives the JDBC driver a hint as to the number of rows that should
1332 * be fetched from the database when more rows are needed for this
1333 * <code>ResultSet</code> object.
1334 * If the fetch size specified is zero, the JDBC driver
1335 * ignores the value and is free to make its own best guess as to what
1336 * the fetch size should be. The default value is set by the
1337 * <code>Statement</code> object
1338 * that created the result set. The fetch size may be changed at any time.
1339 *
1340 * @param rows the number of rows to fetch
1341 * @exception SQLException if a database access error occurs; this method
1342 * is called on a closed result set or the
1343 * condition <code>rows >= 0 </code> is not satisfied
1344 * @since 1.2
1345 * @see #getFetchSize
1346 */
1347 void setFetchSize(int rows) throws SQLException;
1348
1349 /**
1350 * Retrieves the fetch size for this
1351 * <code>ResultSet</code> object.
1352 *
1353 * @return the current fetch size for this <code>ResultSet</code> object
1354 * @exception SQLException if a database access error occurs
1355 * or this method is called on a closed result set
1356 * @since 1.2
1357 * @see #setFetchSize
1358 */
1359 int getFetchSize() throws SQLException;
1360
1361 /**
1362 * The constant indicating the type for a <code>ResultSet</code> object
1363 * whose cursor may move only forward.
1364 * @since 1.2
1365 */
1366 int TYPE_FORWARD_ONLY = 1003;
1367
1368 /**
1369 * The constant indicating the type for a <code>ResultSet</code> object
1370 * that is scrollable but generally not sensitive to changes to the data
1371 * that underlies the <code>ResultSet</code>.
1372 * @since 1.2
1373 */
1374 int TYPE_SCROLL_INSENSITIVE = 1004;
1375
1376 /**
1377 * The constant indicating the type for a <code>ResultSet</code> object
1378 * that is scrollable and generally sensitive to changes to the data
1379 * that underlies the <code>ResultSet</code>.
1380 * @since 1.2
1381 */
1382 int TYPE_SCROLL_SENSITIVE = 1005;
1383
1384 /**
1385 * Retrieves the type of this <code>ResultSet</code> object.
1386 * The type is determined by the <code>Statement</code> object
1387 * that created the result set.
1388 *
1389 * @return <code>ResultSet.TYPE_FORWARD_ONLY</code>,
1390 * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>,
1391 * or <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
1392 * @exception SQLException if a database access error occurs
1393 * or this method is called on a closed result set
1394 * @since 1.2
1395 */
1396 int getType() throws SQLException;
1397
1398 /**
1399 * The constant indicating the concurrency mode for a
1400 * <code>ResultSet</code> object that may NOT be updated.
1401 * @since 1.2
1402 */
1403 int CONCUR_READ_ONLY = 1007;
1404
1405 /**
1406 * The constant indicating the concurrency mode for a
1407 * <code>ResultSet</code> object that may be updated.
1408 * @since 1.2
1409 */
1410 int CONCUR_UPDATABLE = 1008;
1411
1412 /**
1413 * Retrieves the concurrency mode of this <code>ResultSet</code> object.
1414 * The concurrency used is determined by the
1415 * <code>Statement</code> object that created the result set.
1416 *
1417 * @return the concurrency type, either
1418 * <code>ResultSet.CONCUR_READ_ONLY</code>
1419 * or <code>ResultSet.CONCUR_UPDATABLE</code>
1420 * @exception SQLException if a database access error occurs
1421 * or this method is called on a closed result set
1422 * @since 1.2
1423 */
1424 int getConcurrency() throws SQLException;
1425
1426 //---------------------------------------------------------------------
1427 // Updates
1428 //---------------------------------------------------------------------
1429
1430 /**
1431 * Retrieves whether the current row has been updated. The value returned
1432 * depends on whether or not the result set can detect updates.
1433 * <p>
1434 * <strong>Note:</strong> Support for the <code>rowUpdated</code> method is optional with a result set
1435 * concurrency of <code>CONCUR_READ_ONLY</code>
1436 * @return <code>true</code> if the current row is detected to
1437 * have been visibly updated by the owner or another; <code>false</code> otherwise
1438 * @exception SQLException if a database access error occurs
1439 * or this method is called on a closed result set
1440 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1441 * this method
1442 * @see DatabaseMetaData#updatesAreDetected
1443 * @since 1.2
1444 */
1445 boolean rowUpdated() throws SQLException;
1446
1447 /**
1448 * Retrieves whether the current row has had an insertion.
1449 * The value returned depends on whether or not this
1450 * <code>ResultSet</code> object can detect visible inserts.
1451 * <p>
1452 * <strong>Note:</strong> Support for the <code>rowInserted</code> method is optional with a result set
1453 * concurrency of <code>CONCUR_READ_ONLY</code>
1454 * @return <code>true</code> if the current row is detected to
1455 * have been inserted; <code>false</code> otherwise
1456 * @exception SQLException if a database access error occurs
1457 * or this method is called on a closed result set
1458 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1459 * this method
1460 *
1461 * @see DatabaseMetaData#insertsAreDetected
1462 * @since 1.2
1463 */
1464 boolean rowInserted() throws SQLException;
1465
1466 /**
1467 * Retrieves whether a row has been deleted. A deleted row may leave
1468 * a visible "hole" in a result set. This method can be used to
1469 * detect holes in a result set. The value returned depends on whether
1470 * or not this <code>ResultSet</code> object can detect deletions.
1471 * <p>
1472 * <strong>Note:</strong> Support for the <code>rowDeleted</code> method is optional with a result set
1473 * concurrency of <code>CONCUR_READ_ONLY</code>
1474 * @return <code>true</code> if the current row is detected to
1475 * have been deleted by the owner or another; <code>false</code> otherwise
1476 * @exception SQLException if a database access error occurs
1477 * or this method is called on a closed result set
1478 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1479 * this method
1480 *
1481 * @see DatabaseMetaData#deletesAreDetected
1482 * @since 1.2
1483 */
1484 boolean rowDeleted() throws SQLException;
1485
1486 /**
1487 * Updates the designated column with a <code>null</code> value.
1488 *
1489 * The updater methods are used to update column values in the
1490 * current row or the insert row. The updater methods do not
1491 * update the underlying database; instead the <code>updateRow</code>
1492 * or <code>insertRow</code> methods are called to update the database.
1493 *
1494 * @param columnIndex the first column is 1, the second is 2, ...
1495 * @exception SQLException if the columnIndex is not valid;
1496 * if a database access error occurs;
1497 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1498 * or this method is called on a closed result set
1499 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1500 * this method
1501 * @since 1.2
1502 */
1503 void updateNull(int columnIndex) throws SQLException;
1504
1505 /**
1506 * Updates the designated column with a <code>boolean</code> value.
1507 * The updater methods are used to update column values in the
1508 * current row or the insert row. The updater methods do not
1509 * update the underlying database; instead the <code>updateRow</code> or
1510 * <code>insertRow</code> methods are called to update the database.
1511 *
1512 * @param columnIndex the first column is 1, the second is 2, ...
1513 * @param x the new column value
1514 * @exception SQLException if the columnIndex is not valid;
1515 * if a database access error occurs;
1516 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1517 * or this method is called on a closed result set
1518 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1519 * this method
1520 * @since 1.2
1521 */
1522 void updateBoolean(int columnIndex, boolean x) throws SQLException;
1523
1524 /**
1525 * Updates the designated column with a <code>byte</code> value.
1526 * The updater methods are used to update column values in the
1527 * current row or the insert row. The updater methods do not
1528 * update the underlying database; instead the <code>updateRow</code> or
1529 * <code>insertRow</code> methods are called to update the database.
1530 *
1531 *
1532 * @param columnIndex the first column is 1, the second is 2, ...
1533 * @param x the new column value
1534 * @exception SQLException if the columnIndex is not valid;
1535 * if a database access error occurs;
1536 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1537 * or this method is called on a closed result set
1538 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1539 * this method
1540 * @since 1.2
1541 */
1542 void updateByte(int columnIndex, byte x) throws SQLException;
1543
1544 /**
1545 * Updates the designated column with a <code>short</code> value.
1546 * The updater methods are used to update column values in the
1547 * current row or the insert row. The updater methods do not
1548 * update the underlying database; instead the <code>updateRow</code> or
1549 * <code>insertRow</code> methods are called to update the database.
1550 *
1551 * @param columnIndex the first column is 1, the second is 2, ...
1552 * @param x the new column value
1553 * @exception SQLException if the columnIndex is not valid;
1554 * if a database access error occurs;
1555 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1556 * or this method is called on a closed result set
1557 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1558 * this method
1559 * @since 1.2
1560 */
1561 void updateShort(int columnIndex, short x) throws SQLException;
1562
1563 /**
1564 * Updates the designated column with an <code>int</code> value.
1565 * The updater methods are used to update column values in the
1566 * current row or the insert row. The updater methods do not
1567 * update the underlying database; instead the <code>updateRow</code> or
1568 * <code>insertRow</code> methods are called to update the database.
1569 *
1570 * @param columnIndex the first column is 1, the second is 2, ...
1571 * @param x the new column value
1572 * @exception SQLException if the columnIndex is not valid;
1573 * if a database access error occurs;
1574 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1575 * or this method is called on a closed result set
1576 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1577 * this method
1578 * @since 1.2
1579 */
1580 void updateInt(int columnIndex, int x) throws SQLException;
1581
1582 /**
1583 * Updates the designated column with a <code>long</code> value.
1584 * The updater methods are used to update column values in the
1585 * current row or the insert row. The updater methods do not
1586 * update the underlying database; instead the <code>updateRow</code> or
1587 * <code>insertRow</code> methods are called to update the database.
1588 *
1589 * @param columnIndex the first column is 1, the second is 2, ...
1590 * @param x the new column value
1591 * @exception SQLException if the columnIndex is not valid;
1592 * if a database access error occurs;
1593 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1594 * or this method is called on a closed result set
1595 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1596 * this method
1597 * @since 1.2
1598 */
1599 void updateLong(int columnIndex, long x) throws SQLException;
1600
1601 /**
1602 * Updates the designated column with a <code>float</code> value.
1603 * The updater methods are used to update column values in the
1604 * current row or the insert row. The updater methods do not
1605 * update the underlying database; instead the <code>updateRow</code> or
1606 * <code>insertRow</code> methods are called to update the database.
1607 *
1608 * @param columnIndex the first column is 1, the second is 2, ...
1609 * @param x the new column value
1610 * @exception SQLException if the columnIndex is not valid;
1611 * if a database access error occurs;
1612 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1613 * or this method is called on a closed result set
1614 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1615 * this method
1616 * @since 1.2
1617 */
1618 void updateFloat(int columnIndex, float x) throws SQLException;
1619
1620 /**
1621 * Updates the designated column with a <code>double</code> value.
1622 * The updater methods are used to update column values in the
1623 * current row or the insert row. The updater methods do not
1624 * update the underlying database; instead the <code>updateRow</code> or
1625 * <code>insertRow</code> methods are called to update the database.
1626 *
1627 * @param columnIndex the first column is 1, the second is 2, ...
1628 * @param x the new column value
1629 * @exception SQLException if the columnIndex is not valid;
1630 * if a database access error occurs;
1631 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1632 * or this method is called on a closed result set
1633 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1634 * this method
1635 * @since 1.2
1636 */
1637 void updateDouble(int columnIndex, double x) throws SQLException;
1638
1639 /**
1640 * Updates the designated column with a <code>java.math.BigDecimal</code>
1641 * value.
1642 * The updater methods are used to update column values in the
1643 * current row or the insert row. The updater methods do not
1644 * update the underlying database; instead the <code>updateRow</code> or
1645 * <code>insertRow</code> methods are called to update the database.
1646 *
1647 * @param columnIndex the first column is 1, the second is 2, ...
1648 * @param x the new column value
1649 * @exception SQLException if the columnIndex is not valid;
1650 * if a database access error occurs;
1651 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1652 * or this method is called on a closed result set
1653 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1654 * this method
1655 * @since 1.2
1656 */
1657 void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException;
1658
1659 /**
1660 * Updates the designated column with a <code>String</code> value.
1661 * The updater methods are used to update column values in the
1662 * current row or the insert row. The updater methods do not
1663 * update the underlying database; instead the <code>updateRow</code> or
1664 * <code>insertRow</code> methods are called to update the database.
1665 *
1666 * @param columnIndex the first column is 1, the second is 2, ...
1667 * @param x the new column value
1668 * @exception SQLException if the columnIndex is not valid;
1669 * if a database access error occurs;
1670 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1671 * or this method is called on a closed result set
1672 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1673 * this method
1674 * @since 1.2
1675 */
1676 void updateString(int columnIndex, String x) throws SQLException;
1677
1678 /**
1679 * Updates the designated column with a <code>byte</code> array value.
1680 * The updater methods are used to update column values in the
1681 * current row or the insert row. The updater methods do not
1682 * update the underlying database; instead the <code>updateRow</code> or
1683 * <code>insertRow</code> methods are called to update the database.
1684 *
1685 * @param columnIndex the first column is 1, the second is 2, ...
1686 * @param x the new column value
1687 * @exception SQLException if the columnIndex is not valid;
1688 * if a database access error occurs;
1689 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1690 * or this method is called on a closed result set
1691 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1692 * this method
1693 * @since 1.2
1694 */
1695 void updateBytes(int columnIndex, byte x[]) throws SQLException;
1696
1697 /**
1698 * Updates the designated column with a <code>java.sql.Date</code> value.
1699 * The updater methods are used to update column values in the
1700 * current row or the insert row. The updater methods do not
1701 * update the underlying database; instead the <code>updateRow</code> or
1702 * <code>insertRow</code> methods are called to update the database.
1703 *
1704 * @param columnIndex the first column is 1, the second is 2, ...
1705 * @param x the new column value
1706 * @exception SQLException if the columnIndex is not valid;
1707 * if a database access error occurs;
1708 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1709 * or this method is called on a closed result set
1710 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1711 * this method
1712 * @since 1.2
1713 */
1714 void updateDate(int columnIndex, java.sql.Date x) throws SQLException;
1715
1716 /**
1717 * Updates the designated column with a <code>java.sql.Time</code> value.
1718 * The updater methods are used to update column values in the
1719 * current row or the insert row. The updater methods do not
1720 * update the underlying database; instead the <code>updateRow</code> or
1721 * <code>insertRow</code> methods are called to update the database.
1722 *
1723 * @param columnIndex the first column is 1, the second is 2, ...
1724 * @param x the new column value
1725 * @exception SQLException if the columnIndex is not valid;
1726 * if a database access error occurs;
1727 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1728 * or this method is called on a closed result set
1729 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1730 * this method
1731 * @since 1.2
1732 */
1733 void updateTime(int columnIndex, java.sql.Time x) throws SQLException;
1734
1735 /**
1736 * Updates the designated column with a <code>java.sql.Timestamp</code>
1737 * value.
1738 * The updater methods are used to update column values in the
1739 * current row or the insert row. The updater methods do not
1740 * update the underlying database; instead the <code>updateRow</code> or
1741 * <code>insertRow</code> methods are called to update the database.
1742 *
1743 * @param columnIndex the first column is 1, the second is 2, ...
1744 * @param x the new column value
1745 * @exception SQLException if the columnIndex is not valid;
1746 * if a database access error occurs;
1747 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1748 * or this method is called on a closed result set
1749 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1750 * this method
1751 * @since 1.2
1752 */
1753 void updateTimestamp(int columnIndex, java.sql.Timestamp x)
1754 throws SQLException;
1755
1756 /**
1757 * Updates the designated column with an ascii stream value, which will have
1758 * the specified number of bytes.
1759 * The updater methods are used to update column values in the
1760 * current row or the insert row. The updater methods do not
1761 * update the underlying database; instead the <code>updateRow</code> or
1762 * <code>insertRow</code> methods are called to update the database.
1763 *
1764 * @param columnIndex the first column is 1, the second is 2, ...
1765 * @param x the new column value
1766 * @param length the length of the stream
1767 * @exception SQLException if the columnIndex is not valid;
1768 * if a database access error occurs;
1769 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1770 * or this method is called on a closed result set
1771 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1772 * this method
1773 * @since 1.2
1774 */
1775 void updateAsciiStream(int columnIndex,
1776 java.io.InputStream x,
1777 int length) throws SQLException;
1778
1779 /**
1780 * Updates the designated column with a binary stream value, which will have
1781 * the specified number of bytes.
1782 * The updater methods are used to update column values in the
1783 * current row or the insert row. The updater methods do not
1784 * update the underlying database; instead the <code>updateRow</code> or
1785 * <code>insertRow</code> methods are called to update the database.
1786 *
1787 * @param columnIndex the first column is 1, the second is 2, ...
1788 * @param x the new column value
1789 * @param length the length of the stream
1790 * @exception SQLException if the columnIndex is not valid;
1791 * if a database access error occurs;
1792 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1793 * or this method is called on a closed result set
1794 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1795 * this method
1796 * @since 1.2
1797 */
1798 void updateBinaryStream(int columnIndex,
1799 java.io.InputStream x,
1800 int length) throws SQLException;
1801
1802 /**
1803 * Updates the designated column with a character stream value, which will have
1804 * the specified number of bytes.
1805 * The updater methods are used to update column values in the
1806 * current row or the insert row. The updater methods do not
1807 * update the underlying database; instead the <code>updateRow</code> or
1808 * <code>insertRow</code> methods are called to update the database.
1809 *
1810 * @param columnIndex the first column is 1, the second is 2, ...
1811 * @param x the new column value
1812 * @param length the length of the stream
1813 * @exception SQLException if the columnIndex is not valid;
1814 * if a database access error occurs;
1815 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1816 * or this method is called on a closed result set
1817 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1818 * this method
1819 * @since 1.2
1820 */
1821 void updateCharacterStream(int columnIndex,
1822 java.io.Reader x,
1823 int length) throws SQLException;
1824
1825 /**
1826 * Updates the designated column with an <code>Object</code> value.
1827 * The updater methods are used to update column values in the
1828 * current row or the insert row. The updater methods do not
1829 * update the underlying database; instead the <code>updateRow</code> or
1830 * <code>insertRow</code> methods are called to update the database.
1831 *<p>
1832 * If the second argument is an <code>InputStream</code> then the stream must contain
1833 * the number of bytes specified by scaleOrLength. If the second argument is a
1834 * <code>Reader</code> then the reader must contain the number of characters specified
1835 * by scaleOrLength. If these conditions are not true the driver will generate a
1836 * <code>SQLException</code> when the statement is executed.
1837 *
1838 * @param columnIndex the first column is 1, the second is 2, ...
1839 * @param x the new column value
1840 * @param scaleOrLength for an object of <code>java.math.BigDecimal</code> ,
1841 * this is the number of digits after the decimal point. For
1842 * Java Object types <code>InputStream</code> and <code>Reader</code>,
1843 * this is the length
1844 * of the data in the stream or reader. For all other types,
1845 * this value will be ignored.
1846 * @exception SQLException if the columnIndex is not valid;
1847 * if a database access error occurs;
1848 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1849 * or this method is called on a closed result set
1850 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1851 * this method
1852 * @since 1.2
1853 */
1854 void updateObject(int columnIndex, Object x, int scaleOrLength)
1855 throws SQLException;
1856
1857 /**
1858 * Updates the designated column with an <code>Object</code> value.
1859 * The updater methods are used to update column values in the
1860 * current row or the insert row. The updater methods do not
1861 * update the underlying database; instead the <code>updateRow</code> or
1862 * <code>insertRow</code> methods are called to update the database.
1863 *
1864 * @param columnIndex the first column is 1, the second is 2, ...
1865 * @param x the new column value
1866 * @exception SQLException if the columnIndex is not valid;
1867 * if a database access error occurs;
1868 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1869 * or this method is called on a closed result set
1870 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1871 * this method
1872 * @since 1.2
1873 */
1874 void updateObject(int columnIndex, Object x) throws SQLException;
1875
1876 /**
1877 * Updates the designated column with a <code>null</code> value.
1878 * The updater methods are used to update column values in the
1879 * current row or the insert row. The updater methods do not
1880 * update the underlying database; instead the <code>updateRow</code> or
1881 * <code>insertRow</code> methods are called to update the database.
1882 *
1883 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
1884 * @exception SQLException if the columnLabel is not valid;
1885 * if a database access error occurs;
1886 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1887 * or this method is called on a closed result set
1888 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1889 * this method
1890 * @since 1.2
1891 */
1892 void updateNull(String columnLabel) throws SQLException;
1893
1894 /**
1895 * Updates the designated column with a <code>boolean</code> value.
1896 * The updater methods are used to update column values in the
1897 * current row or the insert row. The updater methods do not
1898 * update the underlying database; instead the <code>updateRow</code> or
1899 * <code>insertRow</code> methods are called to update the database.
1900 *
1901 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
1902 * @param x the new column value
1903 * @exception SQLException if the columnLabel is not valid;
1904 * if a database access error occurs;
1905 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1906 * or this method is called on a closed result set
1907 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1908 * this method
1909 * @since 1.2
1910 */
1911 void updateBoolean(String columnLabel, boolean x) throws SQLException;
1912
1913 /**
1914 * Updates the designated column with a <code>byte</code> value.
1915 * The updater methods are used to update column values in the
1916 * current row or the insert row. The updater methods do not
1917 * update the underlying database; instead the <code>updateRow</code> or
1918 * <code>insertRow</code> methods are called to update the database.
1919 *
1920 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
1921 * @param x the new column value
1922 * @exception SQLException if the columnLabel is not valid;
1923 * if a database access error occurs;
1924 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1925 * or this method is called on a closed result set
1926 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1927 * this method
1928 * @since 1.2
1929 */
1930 void updateByte(String columnLabel, byte x) throws SQLException;
1931
1932 /**
1933 * Updates the designated column with a <code>short</code> value.
1934 * The updater methods are used to update column values in the
1935 * current row or the insert row. The updater methods do not
1936 * update the underlying database; instead the <code>updateRow</code> or
1937 * <code>insertRow</code> methods are called to update the database.
1938 *
1939 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
1940 * @param x the new column value
1941 * @exception SQLException if the columnLabel is not valid;
1942 * if a database access error occurs;
1943 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1944 * or this method is called on a closed result set
1945 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1946 * this method
1947 * @since 1.2
1948 */
1949 void updateShort(String columnLabel, short x) throws SQLException;
1950
1951 /**
1952 * Updates the designated column with an <code>int</code> value.
1953 * The updater methods are used to update column values in the
1954 * current row or the insert row. The updater methods do not
1955 * update the underlying database; instead the <code>updateRow</code> or
1956 * <code>insertRow</code> methods are called to update the database.
1957 *
1958 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
1959 * @param x the new column value
1960 * @exception SQLException if the columnLabel is not valid;
1961 * if a database access error occurs;
1962 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1963 * or this method is called on a closed result set
1964 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1965 * this method
1966 * @since 1.2
1967 */
1968 void updateInt(String columnLabel, int x) throws SQLException;
1969
1970 /**
1971 * Updates the designated column with a <code>long</code> value.
1972 * The updater methods are used to update column values in the
1973 * current row or the insert row. The updater methods do not
1974 * update the underlying database; instead the <code>updateRow</code> or
1975 * <code>insertRow</code> methods are called to update the database.
1976 *
1977 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
1978 * @param x the new column value
1979 * @exception SQLException if the columnLabel is not valid;
1980 * if a database access error occurs;
1981 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1982 * or this method is called on a closed result set
1983 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1984 * this method
1985 * @since 1.2
1986 */
1987 void updateLong(String columnLabel, long x) throws SQLException;
1988
1989 /**
1990 * Updates the designated column with a <code>float </code> value.
1991 * The updater methods are used to update column values in the
1992 * current row or the insert row. The updater methods do not
1993 * update the underlying database; instead the <code>updateRow</code> or
1994 * <code>insertRow</code> methods are called to update the database.
1995 *
1996 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
1997 * @param x the new column value
1998 * @exception SQLException if the columnLabel is not valid;
1999 * if a database access error occurs;
2000 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2001 * or this method is called on a closed result set
2002 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2003 * this method
2004 * @since 1.2
2005 */
2006 void updateFloat(String columnLabel, float x) throws SQLException;
2007
2008 /**
2009 * Updates the designated column with a <code>double</code> value.
2010 * The updater methods are used to update column values in the
2011 * current row or the insert row. The updater methods do not
2012 * update the underlying database; instead the <code>updateRow</code> or
2013 * <code>insertRow</code> methods are called to update the database.
2014 *
2015 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2016 * @param x the new column value
2017 * @exception SQLException if the columnLabel is not valid;
2018 * if a database access error occurs;
2019 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2020 * or this method is called on a closed result set
2021 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2022 * this method
2023 * @since 1.2
2024 */
2025 void updateDouble(String columnLabel, double x) throws SQLException;
2026
2027 /**
2028 * Updates the designated column with a <code>java.sql.BigDecimal</code>
2029 * value.
2030 * The updater methods are used to update column values in the
2031 * current row or the insert row. The updater methods do not
2032 * update the underlying database; instead the <code>updateRow</code> or
2033 * <code>insertRow</code> methods are called to update the database.
2034 *
2035 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2036 * @param x the new column value
2037 * @exception SQLException if the columnLabel is not valid;
2038 * if a database access error occurs;
2039 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2040 * or this method is called on a closed result set
2041 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2042 * this method
2043 * @since 1.2
2044 */
2045 void updateBigDecimal(String columnLabel, BigDecimal x) throws SQLException;
2046
2047 /**
2048 * Updates the designated column with a <code>String</code> value.
2049 * The updater methods are used to update column values in the
2050 * current row or the insert row. The updater methods do not
2051 * update the underlying database; instead the <code>updateRow</code> or
2052 * <code>insertRow</code> methods are called to update the database.
2053 *
2054 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2055 * @param x the new column value
2056 * @exception SQLException if the columnLabel is not valid;
2057 * if a database access error occurs;
2058 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2059 * or this method is called on a closed result set
2060 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2061 * this method
2062 * @since 1.2
2063 */
2064 void updateString(String columnLabel, String x) throws SQLException;
2065
2066 /**
2067 * Updates the designated column with a byte array value.
2068 *
2069 * The updater methods are used to update column values in the
2070 * current row or the insert row. The updater methods do not
2071 * update the underlying database; instead the <code>updateRow</code>
2072 * or <code>insertRow</code> methods are called to update the database.
2073 *
2074 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2075 * @param x the new column value
2076 * @exception SQLException if the columnLabel is not valid;
2077 * if a database access error occurs;
2078 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2079 * or this method is called on a closed result set
2080 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2081 * this method
2082 * @since 1.2
2083 */
2084 void updateBytes(String columnLabel, byte x[]) throws SQLException;
2085
2086 /**
2087 * Updates the designated column with a <code>java.sql.Date</code> value.
2088 * The updater methods are used to update column values in the
2089 * current row or the insert row. The updater methods do not
2090 * update the underlying database; instead the <code>updateRow</code> or
2091 * <code>insertRow</code> methods are called to update the database.
2092 *
2093 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2094 * @param x the new column value
2095 * @exception SQLException if the columnLabel is not valid;
2096 * if a database access error occurs;
2097 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2098 * or this method is called on a closed result set
2099 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2100 * this method
2101 * @since 1.2
2102 */
2103 void updateDate(String columnLabel, java.sql.Date x) throws SQLException;
2104
2105 /**
2106 * Updates the designated column with a <code>java.sql.Time</code> value.
2107 * The updater methods are used to update column values in the
2108 * current row or the insert row. The updater methods do not
2109 * update the underlying database; instead the <code>updateRow</code> or
2110 * <code>insertRow</code> methods are called to update the database.
2111 *
2112 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2113 * @param x the new column value
2114 * @exception SQLException if the columnLabel is not valid;
2115 * if a database access error occurs;
2116 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2117 * or this method is called on a closed result set
2118 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2119 * this method
2120 * @since 1.2
2121 */
2122 void updateTime(String columnLabel, java.sql.Time x) throws SQLException;
2123
2124 /**
2125 * Updates the designated column with a <code>java.sql.Timestamp</code>
2126 * value.
2127 * The updater methods are used to update column values in the
2128 * current row or the insert row. The updater methods do not
2129 * update the underlying database; instead the <code>updateRow</code> or
2130 * <code>insertRow</code> methods are called to update the database.
2131 *
2132 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2133 * @param x the new column value
2134 * @exception SQLException if the columnLabel is not valid;
2135 * if a database access error occurs;
2136 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2137 * or this method is called on a closed result set
2138 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2139 * this method
2140 * @since 1.2
2141 */
2142 void updateTimestamp(String columnLabel, java.sql.Timestamp x)
2143 throws SQLException;
2144
2145 /**
2146 * Updates the designated column with an ascii stream value, which will have
2147 * the specified number of bytes.
2148 * The updater methods are used to update column values in the
2149 * current row or the insert row. The updater methods do not
2150 * update the underlying database; instead the <code>updateRow</code> or
2151 * <code>insertRow</code> methods are called to update the database.
2152 *
2153 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2154 * @param x the new column value
2155 * @param length the length of the stream
2156 * @exception SQLException if the columnLabel is not valid;
2157 * if a database access error occurs;
2158 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2159 * or this method is called on a closed result set
2160 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2161 * this method
2162 * @since 1.2
2163 */
2164 void updateAsciiStream(String columnLabel,
2165 java.io.InputStream x,
2166 int length) throws SQLException;
2167
2168 /**
2169 * Updates the designated column with a binary stream value, which will have
2170 * the specified number of bytes.
2171 * The updater methods are used to update column values in the
2172 * current row or the insert row. The updater methods do not
2173 * update the underlying database; instead the <code>updateRow</code> or
2174 * <code>insertRow</code> methods are called to update the database.
2175 *
2176 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2177 * @param x the new column value
2178 * @param length the length of the stream
2179 * @exception SQLException if the columnLabel is not valid;
2180 * if a database access error occurs;
2181 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2182 * or this method is called on a closed result set
2183 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2184 * this method
2185 * @since 1.2
2186 */
2187 void updateBinaryStream(String columnLabel,
2188 java.io.InputStream x,
2189 int length) throws SQLException;
2190
2191 /**
2192 * Updates the designated column with a character stream value, which will have
2193 * the specified number of bytes.
2194 * The updater methods are used to update column values in the
2195 * current row or the insert row. The updater methods do not
2196 * update the underlying database; instead the <code>updateRow</code> or
2197 * <code>insertRow</code> methods are called to update the database.
2198 *
2199 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2200 * @param reader the <code>java.io.Reader</code> object containing
2201 * the new column value
2202 * @param length the length of the stream
2203 * @exception SQLException if the columnLabel is not valid;
2204 * if a database access error occurs;
2205 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2206 * or this method is called on a closed result set
2207 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2208 * this method
2209 * @since 1.2
2210 */
2211 void updateCharacterStream(String columnLabel,
2212 java.io.Reader reader,
2213 int length) throws SQLException;
2214
2215 /**
2216 * Updates the designated column with an <code>Object</code> value.
2217 * The updater methods are used to update column values in the
2218 * current row or the insert row. The updater methods do not
2219 * update the underlying database; instead the <code>updateRow</code> or
2220 * <code>insertRow</code> methods are called to update the database.
2221 *<p>
2222 * If the second argument is an <code>InputStream</code> then the stream must contain
2223 * the number of bytes specified by scaleOrLength. If the second argument is a
2224 * <code>Reader</code> then the reader must contain the number of characters specified
2225 * by scaleOrLength. If these conditions are not true the driver will generate a
2226 * <code>SQLException</code> when the statement is executed.
2227 *
2228 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2229 * @param x the new column value
2230 * @param scaleOrLength for an object of <code>java.math.BigDecimal</code> ,
2231 * this is the number of digits after the decimal point. For
2232 * Java Object types <code>InputStream</code> and <code>Reader</code>,
2233 * this is the length
2234 * of the data in the stream or reader. For all other types,
2235 * this value will be ignored.
2236 * @exception SQLException if the columnLabel is not valid;
2237 * if a database access error occurs;
2238 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2239 * or this method is called on a closed result set
2240 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2241 * this method
2242 * @since 1.2
2243 */
2244 void updateObject(String columnLabel, Object x, int scaleOrLength)
2245 throws SQLException;
2246
2247 /**
2248 * Updates the designated column with an <code>Object</code> value.
2249 * The updater methods are used to update column values in the
2250 * current row or the insert row. The updater methods do not
2251 * update the underlying database; instead the <code>updateRow</code> or
2252 * <code>insertRow</code> methods are called to update the database.
2253 *
2254 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2255 * @param x the new column value
2256 * @exception SQLException if the columnLabel is not valid;
2257 * if a database access error occurs;
2258 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2259 * or this method is called on a closed result set
2260 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2261 * this method
2262 * @since 1.2
2263 */
2264 void updateObject(String columnLabel, Object x) throws SQLException;
2265
2266 /**
2267 * Inserts the contents of the insert row into this
2268 * <code>ResultSet</code> object and into the database.
2269 * The cursor must be on the insert row when this method is called.
2270 *
2271 * @exception SQLException if a database access error occurs;
2272 * the result set concurrency is <code>CONCUR_READ_ONLY</code>,
2273 * this method is called on a closed result set,
2274 * if this method is called when the cursor is not on the insert row,
2275 * or if not all of non-nullable columns in
2276 * the insert row have been given a non-null value
2277 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2278 * this method
2279 * @since 1.2
2280 */
2281 void insertRow() throws SQLException;
2282
2283 /**
2284 * Updates the underlying database with the new contents of the
2285 * current row of this <code>ResultSet</code> object.
2286 * This method cannot be called when the cursor is on the insert row.
2287 *
2288 * @exception SQLException if a database access error occurs;
2289 * the result set concurrency is <code>CONCUR_READ_ONLY</code>;
2290 * this method is called on a closed result set or
2291 * if this method is called when the cursor is on the insert row
2292 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2293 * this method
2294 * @since 1.2
2295 */
2296 void updateRow() throws SQLException;
2297
2298 /**
2299 * Deletes the current row from this <code>ResultSet</code> object
2300 * and from the underlying database. This method cannot be called when
2301 * the cursor is on the insert row.
2302 *
2303 * @exception SQLException if a database access error occurs;
2304 * the result set concurrency is <code>CONCUR_READ_ONLY</code>;
2305 * this method is called on a closed result set
2306 * or if this method is called when the cursor is on the insert row
2307 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2308 * this method
2309 * @since 1.2
2310 */
2311 void deleteRow() throws SQLException;
2312
2313 /**
2314 * Refreshes the current row with its most recent value in
2315 * the database. This method cannot be called when
2316 * the cursor is on the insert row.
2317 *
2318 * <P>The <code>refreshRow</code> method provides a way for an
2319 * application to
2320 * explicitly tell the JDBC driver to refetch a row(s) from the
2321 * database. An application may want to call <code>refreshRow</code> when
2322 * caching or prefetching is being done by the JDBC driver to
2323 * fetch the latest value of a row from the database. The JDBC driver
2324 * may actually refresh multiple rows at once if the fetch size is
2325 * greater than one.
2326 *
2327 * <P> All values are refetched subject to the transaction isolation
2328 * level and cursor sensitivity. If <code>refreshRow</code> is called after
2329 * calling an updater method, but before calling
2330 * the method <code>updateRow</code>, then the
2331 * updates made to the row are lost. Calling the method
2332 * <code>refreshRow</code> frequently will likely slow performance.
2333 *
2334 * @exception SQLException if a database access error
2335 * occurs; this method is called on a closed result set;
2336 * the result set type is <code>TYPE_FORWARD_ONLY</code> or if this
2337 * method is called when the cursor is on the insert row
2338 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2339 * this method or this method is not supported for the specified result
2340 * set type and result set concurrency.
2341 * @since 1.2
2342 */
2343 void refreshRow() throws SQLException;
2344
2345 /**
2346 * Cancels the updates made to the current row in this
2347 * <code>ResultSet</code> object.
2348 * This method may be called after calling an
2349 * updater method(s) and before calling
2350 * the method <code>updateRow</code> to roll back
2351 * the updates made to a row. If no updates have been made or
2352 * <code>updateRow</code> has already been called, this method has no
2353 * effect.
2354 *
2355 * @exception SQLException if a database access error
2356 * occurs; this method is called on a closed result set;
2357 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2358 * or if this method is called when the cursor is
2359 * on the insert row
2360 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2361 * this method
2362 * @since 1.2
2363 */
2364 void cancelRowUpdates() throws SQLException;
2365
2366 /**
2367 * Moves the cursor to the insert row. The current cursor position is
2368 * remembered while the cursor is positioned on the insert row.
2369 *
2370 * The insert row is a special row associated with an updatable
2371 * result set. It is essentially a buffer where a new row may
2372 * be constructed by calling the updater methods prior to
2373 * inserting the row into the result set.
2374 *
2375 * Only the updater, getter,
2376 * and <code>insertRow</code> methods may be
2377 * called when the cursor is on the insert row. All of the columns in
2378 * a result set must be given a value each time this method is
2379 * called before calling <code>insertRow</code>.
2380 * An updater method must be called before a
2381 * getter method can be called on a column value.
2382 *
2383 * @exception SQLException if a database access error occurs; this
2384 * method is called on a closed result set
2385 * or the result set concurrency is <code>CONCUR_READ_ONLY</code>
2386 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2387 * this method
2388 * @since 1.2
2389 */
2390 void moveToInsertRow() throws SQLException;
2391
2392 /**
2393 * Moves the cursor to the remembered cursor position, usually the
2394 * current row. This method has no effect if the cursor is not on
2395 * the insert row.
2396 *
2397 * @exception SQLException if a database access error occurs; this
2398 * method is called on a closed result set
2399 * or the result set concurrency is <code>CONCUR_READ_ONLY</code>
2400 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2401 * this method
2402 * @since 1.2
2403 */
2404 void moveToCurrentRow() throws SQLException;
2405
2406 /**
2407 * Retrieves the <code>Statement</code> object that produced this
2408 * <code>ResultSet</code> object.
2409 * If the result set was generated some other way, such as by a
2410 * <code>DatabaseMetaData</code> method, this method may return
2411 * <code>null</code>.
2412 *
2413 * @return the <code>Statment</code> object that produced
2414 * this <code>ResultSet</code> object or <code>null</code>
2415 * if the result set was produced some other way
2416 * @exception SQLException if a database access error occurs
2417 * or this method is called on a closed result set
2418 * @since 1.2
2419 */
2420 Statement getStatement() throws SQLException;
2421
2422 /**
2423 * Retrieves the value of the designated column in the current row
2424 * of this <code>ResultSet</code> object as an <code>Object</code>
2425 * in the Java programming language.
2426 * If the value is an SQL <code>NULL</code>,
2427 * the driver returns a Java <code>null</code>.
2428 * This method uses the given <code>Map</code> object
2429 * for the custom mapping of the
2430 * SQL structured or distinct type that is being retrieved.
2431 *
2432 * @param columnIndex the first column is 1, the second is 2, ...
2433 * @param map a <code>java.util.Map</code> object that contains the mapping
2434 * from SQL type names to classes in the Java programming language
2435 * @return an <code>Object</code> in the Java programming language
2436 * representing the SQL value
2437 * @exception SQLException if the columnIndex is not valid;
2438 * if a database access error occurs
2439 * or this method is called on a closed result set
2440 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2441 * this method
2442 * @since 1.2
2443 */
2444 Object getObject(int columnIndex, java.util.Map<String,Class<?>> map)
2445 throws SQLException;
2446
2447 /**
2448 * Retrieves the value of the designated column in the current row
2449 * of this <code>ResultSet</code> object as a <code>Ref</code> object
2450 * in the Java programming language.
2451 *
2452 * @param columnIndex the first column is 1, the second is 2, ...
2453 * @return a <code>Ref</code> object representing an SQL <code>REF</code>
2454 * value
2455 * @exception SQLException if the columnIndex is not valid;
2456 * if a database access error occurs
2457 * or this method is called on a closed result set
2458 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2459 * this method
2460 * @since 1.2
2461 */
2462 Ref getRef(int columnIndex) throws SQLException;
2463
2464 /**
2465 * Retrieves the value of the designated column in the current row
2466 * of this <code>ResultSet</code> object as a <code>Blob</code> object
2467 * in the Java programming language.
2468 *
2469 * @param columnIndex the first column is 1, the second is 2, ...
2470 * @return a <code>Blob</code> object representing the SQL
2471 * <code>BLOB</code> value in the specified column
2472 * @exception SQLException if the columnIndex is not valid;
2473 * if a database access error occurs
2474 * or this method is called on a closed result set
2475 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2476 * this method
2477 * @since 1.2
2478 */
2479 Blob getBlob(int columnIndex) throws SQLException;
2480
2481 /**
2482 * Retrieves the value of the designated column in the current row
2483 * of this <code>ResultSet</code> object as a <code>Clob</code> object
2484 * in the Java programming language.
2485 *
2486 * @param columnIndex the first column is 1, the second is 2, ...
2487 * @return a <code>Clob</code> object representing the SQL
2488 * <code>CLOB</code> value in the specified column
2489 * @exception SQLException if the columnIndex is not valid;
2490 * if a database access error occurs
2491 * or this method is called on a closed result set
2492 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2493 * this method
2494 * @since 1.2
2495 */
2496 Clob getClob(int columnIndex) throws SQLException;
2497
2498 /**
2499 * Retrieves the value of the designated column in the current row
2500 * of this <code>ResultSet</code> object as an <code>Array</code> object
2501 * in the Java programming language.
2502 *
2503 * @param columnIndex the first column is 1, the second is 2, ...
2504 * @return an <code>Array</code> object representing the SQL
2505 * <code>ARRAY</code> value in the specified column
2506 * @exception SQLException if the columnIndex is not valid;
2507 * if a database access error occurs
2508 * or this method is called on a closed result set
2509 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2510 * this method
2511 * @since 1.2
2512 */
2513 Array getArray(int columnIndex) throws SQLException;
2514
2515 /**
2516 * Retrieves the value of the designated column in the current row
2517 * of this <code>ResultSet</code> object as an <code>Object</code>
2518 * in the Java programming language.
2519 * If the value is an SQL <code>NULL</code>,
2520 * the driver returns a Java <code>null</code>.
2521 * This method uses the specified <code>Map</code> object for
2522 * custom mapping if appropriate.
2523 *
2524 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2525 * @param map a <code>java.util.Map</code> object that contains the mapping
2526 * from SQL type names to classes in the Java programming language
2527 * @return an <code>Object</code> representing the SQL value in the
2528 * specified column
2529 * @exception SQLException if the columnLabel is not valid;
2530 * if a database access error occurs
2531 * or this method is called on a closed result set
2532 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2533 * this method
2534 * @since 1.2
2535 */
2536 Object getObject(String columnLabel, java.util.Map<String,Class<?>> map)
2537 throws SQLException;
2538
2539 /**
2540 * Retrieves the value of the designated column in the current row
2541 * of this <code>ResultSet</code> object as a <code>Ref</code> object
2542 * in the Java programming language.
2543 *
2544 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2545 * @return a <code>Ref</code> object representing the SQL <code>REF</code>
2546 * value in the specified column
2547 * @exception SQLException if the columnLabel is not valid;
2548 * if a database access error occurs
2549 * or this method is called on a closed result set
2550 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2551 * this method
2552 * @since 1.2
2553 */
2554 Ref getRef(String columnLabel) throws SQLException;
2555
2556 /**
2557 * Retrieves the value of the designated column in the current row
2558 * of this <code>ResultSet</code> object as a <code>Blob</code> object
2559 * in the Java programming language.
2560 *
2561 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2562 * @return a <code>Blob</code> object representing the SQL <code>BLOB</code>
2563 * value in the specified column
2564 * @exception SQLException if the columnLabel is not valid;
2565 * if a database access error occurs
2566 * or this method is called on a closed result set
2567 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2568 * this method
2569 * @since 1.2
2570 */
2571 Blob getBlob(String columnLabel) throws SQLException;
2572
2573 /**
2574 * Retrieves the value of the designated column in the current row
2575 * of this <code>ResultSet</code> object as a <code>Clob</code> object
2576 * in the Java programming language.
2577 *
2578 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2579 * @return a <code>Clob</code> object representing the SQL <code>CLOB</code>
2580 * value in the specified column
2581 * @exception SQLException if the columnLabel is not valid;
2582 * if a database access error occurs
2583 * or this method is called on a closed result set
2584 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2585 * this method
2586 * @since 1.2
2587 */
2588 Clob getClob(String columnLabel) throws SQLException;
2589
2590 /**
2591 * Retrieves the value of the designated column in the current row
2592 * of this <code>ResultSet</code> object as an <code>Array</code> object
2593 * in the Java programming language.
2594 *
2595 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2596 * @return an <code>Array</code> object representing the SQL <code>ARRAY</code> value in
2597 * the specified column
2598 * @exception SQLException if the columnLabel is not valid;
2599 * if a database access error occurs
2600 * or this method is called on a closed result set
2601 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2602 * this method
2603 * @since 1.2
2604 */
2605 Array getArray(String columnLabel) throws SQLException;
2606
2607 /**
2608 * Retrieves the value of the designated column in the current row
2609 * of this <code>ResultSet</code> object as a <code>java.sql.Date</code> object
2610 * in the Java programming language.
2611 * This method uses the given calendar to construct an appropriate millisecond
2612 * value for the date if the underlying database does not store
2613 * timezone information.
2614 *
2615 * @param columnIndex the first column is 1, the second is 2, ...
2616 * @param cal the <code>java.util.Calendar</code> object
2617 * to use in constructing the date
2618 * @return the column value as a <code>java.sql.Date</code> object;
2619 * if the value is SQL <code>NULL</code>,
2620 * the value returned is <code>null</code> in the Java programming language
2621 * @exception SQLException if the columnIndex is not valid;
2622 * if a database access error occurs
2623 * or this method is called on a closed result set
2624 * @since 1.2
2625 */
2626 java.sql.Date getDate(int columnIndex, Calendar cal) throws SQLException;
2627
2628 /**
2629 * Retrieves the value of the designated column in the current row
2630 * of this <code>ResultSet</code> object as a <code>java.sql.Date</code> object
2631 * in the Java programming language.
2632 * This method uses the given calendar to construct an appropriate millisecond
2633 * value for the date if the underlying database does not store
2634 * timezone information.
2635 *
2636 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2637 * @param cal the <code>java.util.Calendar</code> object
2638 * to use in constructing the date
2639 * @return the column value as a <code>java.sql.Date</code> object;
2640 * if the value is SQL <code>NULL</code>,
2641 * the value returned is <code>null</code> in the Java programming language
2642 * @exception SQLException if the columnLabel is not valid;
2643 * if a database access error occurs
2644 * or this method is called on a closed result set
2645 * @since 1.2
2646 */
2647 java.sql.Date getDate(String columnLabel, Calendar cal) throws SQLException;
2648
2649 /**
2650 * Retrieves the value of the designated column in the current row
2651 * of this <code>ResultSet</code> object as a <code>java.sql.Time</code> object
2652 * in the Java programming language.
2653 * This method uses the given calendar to construct an appropriate millisecond
2654 * value for the time if the underlying database does not store
2655 * timezone information.
2656 *
2657 * @param columnIndex the first column is 1, the second is 2, ...
2658 * @param cal the <code>java.util.Calendar</code> object
2659 * to use in constructing the time
2660 * @return the column value as a <code>java.sql.Time</code> object;
2661 * if the value is SQL <code>NULL</code>,
2662 * the value returned is <code>null</code> in the Java programming language
2663 * @exception SQLException if the columnIndex is not valid;
2664 * if a database access error occurs
2665 * or this method is called on a closed result set
2666 * @since 1.2
2667 */
2668 java.sql.Time getTime(int columnIndex, Calendar cal) throws SQLException;
2669
2670 /**
2671 * Retrieves the value of the designated column in the current row
2672 * of this <code>ResultSet</code> object as a <code>java.sql.Time</code> object
2673 * in the Java programming language.
2674 * This method uses the given calendar to construct an appropriate millisecond
2675 * value for the time if the underlying database does not store
2676 * timezone information.
2677 *
2678 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2679 * @param cal the <code>java.util.Calendar</code> object
2680 * to use in constructing the time
2681 * @return the column value as a <code>java.sql.Time</code> object;
2682 * if the value is SQL <code>NULL</code>,
2683 * the value returned is <code>null</code> in the Java programming language
2684 * @exception SQLException if the columnLabel is not valid;
2685 * if a database access error occurs
2686 * or this method is called on a closed result set
2687 * @since 1.2
2688 */
2689 java.sql.Time getTime(String columnLabel, Calendar cal) throws SQLException;
2690
2691 /**
2692 * Retrieves the value of the designated column in the current row
2693 * of this <code>ResultSet</code> object as a <code>java.sql.Timestamp</code> object
2694 * in the Java programming language.
2695 * This method uses the given calendar to construct an appropriate millisecond
2696 * value for the timestamp if the underlying database does not store
2697 * timezone information.
2698 *
2699 * @param columnIndex the first column is 1, the second is 2, ...
2700 * @param cal the <code>java.util.Calendar</code> object
2701 * to use in constructing the timestamp
2702 * @return the column value as a <code>java.sql.Timestamp</code> object;
2703 * if the value is SQL <code>NULL</code>,
2704 * the value returned is <code>null</code> in the Java programming language
2705 * @exception SQLException if the columnIndex is not valid;
2706 * if a database access error occurs
2707 * or this method is called on a closed result set
2708 * @since 1.2
2709 */
2710 java.sql.Timestamp getTimestamp(int columnIndex, Calendar cal)
2711 throws SQLException;
2712
2713 /**
2714 * Retrieves the value of the designated column in the current row
2715 * of this <code>ResultSet</code> object as a <code>java.sql.Timestamp</code> object
2716 * in the Java programming language.
2717 * This method uses the given calendar to construct an appropriate millisecond
2718 * value for the timestamp if the underlying database does not store
2719 * timezone information.
2720 *
2721 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2722 * @param cal the <code>java.util.Calendar</code> object
2723 * to use in constructing the date
2724 * @return the column value as a <code>java.sql.Timestamp</code> object;
2725 * if the value is SQL <code>NULL</code>,
2726 * the value returned is <code>null</code> in the Java programming language
2727 * @exception SQLException if the columnLabel is not valid or
2728 * if a database access error occurs
2729 * or this method is called on a closed result set
2730 * @since 1.2
2731 */
2732 java.sql.Timestamp getTimestamp(String columnLabel, Calendar cal)
2733 throws SQLException;
2734
2735 //-------------------------- JDBC 3.0 ----------------------------------------
2736
2737 /**
2738 * The constant indicating that open <code>ResultSet</code> objects with this
2739 * holdability will remain open when the current transaction is commited.
2740 *
2741 * @since 1.4
2742 */
2743 int HOLD_CURSORS_OVER_COMMIT = 1;
2744
2745 /**
2746 * The constant indicating that open <code>ResultSet</code> objects with this
2747 * holdability will be closed when the current transaction is commited.
2748 *
2749 * @since 1.4
2750 */
2751 int CLOSE_CURSORS_AT_COMMIT = 2;
2752
2753 /**
2754 * Retrieves the value of the designated column in the current row
2755 * of this <code>ResultSet</code> object as a <code>java.net.URL</code>
2756 * object in the Java programming language.
2757 *
2758 * @param columnIndex the index of the column 1 is the first, 2 is the second,...
2759 * @return the column value as a <code>java.net.URL</code> object;
2760 * if the value is SQL <code>NULL</code>,
2761 * the value returned is <code>null</code> in the Java programming language
2762 * @exception SQLException if the columnIndex is not valid;
2763 * if a database access error occurs; this method
2764 * is called on a closed result set or if a URL is malformed
2765 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2766 * this method
2767 * @since 1.4
2768 */
2769 java.net.URL getURL(int columnIndex) throws SQLException;
2770
2771 /**
2772 * Retrieves the value of the designated column in the current row
2773 * of this <code>ResultSet</code> object as a <code>java.net.URL</code>
2774 * object in the Java programming language.
2775 *
2776 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2777 * @return the column value as a <code>java.net.URL</code> object;
2778 * if the value is SQL <code>NULL</code>,
2779 * the value returned is <code>null</code> in the Java programming language
2780 * @exception SQLException if the columnLabel is not valid;
2781 * if a database access error occurs; this method
2782 * is called on a closed result set or if a URL is malformed
2783 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2784 * this method
2785 * @since 1.4
2786 */
2787 java.net.URL getURL(String columnLabel) throws SQLException;
2788
2789 /**
2790 * Updates the designated column with a <code>java.sql.Ref</code> value.
2791 * The updater methods are used to update column values in the
2792 * current row or the insert row. The updater methods do not
2793 * update the underlying database; instead the <code>updateRow</code> or
2794 * <code>insertRow</code> methods are called to update the database.
2795 *
2796 * @param columnIndex the first column is 1, the second is 2, ...
2797 * @param x the new column value
2798 * @exception SQLException if the columnIndex is not valid;
2799 * if a database access error occurs;
2800 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2801 * or this method is called on a closed result set
2802 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2803 * this method
2804 * @since 1.4
2805 */
2806 void updateRef(int columnIndex, java.sql.Ref x) throws SQLException;
2807
2808 /**
2809 * Updates the designated column with a <code>java.sql.Ref</code> value.
2810 * The updater methods are used to update column values in the
2811 * current row or the insert row. The updater methods do not
2812 * update the underlying database; instead the <code>updateRow</code> or
2813 * <code>insertRow</code> methods are called to update the database.
2814 *
2815 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2816 * @param x the new column value
2817 * @exception SQLException if the columnLabel is not valid;
2818 * if a database access error occurs;
2819 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2820 * or this method is called on a closed result set
2821 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2822 * this method
2823 * @since 1.4
2824 */
2825 void updateRef(String columnLabel, java.sql.Ref x) throws SQLException;
2826
2827 /**
2828 * Updates the designated column with a <code>java.sql.Blob</code> value.
2829 * The updater methods are used to update column values in the
2830 * current row or the insert row. The updater methods do not
2831 * update the underlying database; instead the <code>updateRow</code> or
2832 * <code>insertRow</code> methods are called to update the database.
2833 *
2834 * @param columnIndex the first column is 1, the second is 2, ...
2835 * @param x the new column value
2836 * @exception SQLException if the columnIndex is not valid;
2837 * if a database access error occurs;
2838 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2839 * or this method is called on a closed result set
2840 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2841 * this method
2842 * @since 1.4
2843 */
2844 void updateBlob(int columnIndex, java.sql.Blob x) throws SQLException;
2845
2846 /**
2847 * Updates the designated column with a <code>java.sql.Blob</code> value.
2848 * The updater methods are used to update column values in the
2849 * current row or the insert row. The updater methods do not
2850 * update the underlying database; instead the <code>updateRow</code> or
2851 * <code>insertRow</code> methods are called to update the database.
2852 *
2853 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2854 * @param x the new column value
2855 * @exception SQLException if the columnLabel is not valid;
2856 * if a database access error occurs;
2857 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2858 * or this method is called on a closed result set
2859 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2860 * this method
2861 * @since 1.4
2862 */
2863 void updateBlob(String columnLabel, java.sql.Blob x) throws SQLException;
2864
2865 /**
2866 * Updates the designated column with a <code>java.sql.Clob</code> value.
2867 * The updater methods are used to update column values in the
2868 * current row or the insert row. The updater methods do not
2869 * update the underlying database; instead the <code>updateRow</code> or
2870 * <code>insertRow</code> methods are called to update the database.
2871 *
2872 * @param columnIndex the first column is 1, the second is 2, ...
2873 * @param x the new column value
2874 * @exception SQLException if the columnIndex is not valid;
2875 * if a database access error occurs;
2876 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2877 * or this method is called on a closed result set
2878 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2879 * this method
2880 * @since 1.4
2881 */
2882 void updateClob(int columnIndex, java.sql.Clob x) throws SQLException;
2883
2884 /**
2885 * Updates the designated column with a <code>java.sql.Clob</code> value.
2886 * The updater methods are used to update column values in the
2887 * current row or the insert row. The updater methods do not
2888 * update the underlying database; instead the <code>updateRow</code> or
2889 * <code>insertRow</code> methods are called to update the database.
2890 *
2891 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2892 * @param x the new column value
2893 * @exception SQLException if the columnLabel is not valid;
2894 * if a database access error occurs;
2895 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2896 * or this method is called on a closed result set
2897 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2898 * this method
2899 * @since 1.4
2900 */
2901 void updateClob(String columnLabel, java.sql.Clob x) throws SQLException;
2902
2903 /**
2904 * Updates the designated column with a <code>java.sql.Array</code> value.
2905 * The updater methods are used to update column values in the
2906 * current row or the insert row. The updater methods do not
2907 * update the underlying database; instead the <code>updateRow</code> or
2908 * <code>insertRow</code> methods are called to update the database.
2909 *
2910 * @param columnIndex the first column is 1, the second is 2, ...
2911 * @param x the new column value
2912 * @exception SQLException if the columnIndex is not valid;
2913 * if a database access error occurs;
2914 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2915 * or this method is called on a closed result set
2916 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2917 * this method
2918 * @since 1.4
2919 */
2920 void updateArray(int columnIndex, java.sql.Array x) throws SQLException;
2921
2922 /**
2923 * Updates the designated column with a <code>java.sql.Array</code> value.
2924 * The updater methods are used to update column values in the
2925 * current row or the insert row. The updater methods do not
2926 * update the underlying database; instead the <code>updateRow</code> or
2927 * <code>insertRow</code> methods are called to update the database.
2928 *
2929 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2930 * @param x the new column value
2931 * @exception SQLException if the columnLabel is not valid;
2932 * if a database access error occurs;
2933 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2934 * or this method is called on a closed result set
2935 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2936 * this method
2937 * @since 1.4
2938 */
2939 void updateArray(String columnLabel, java.sql.Array x) throws SQLException;
2940
2941 //------------------------- JDBC 4.0 -----------------------------------
2942
2943 /**
2944 * Retrieves the value of the designated column in the current row of this
2945 * <code>ResultSet</code> object as a <code>java.sql.RowId</code> object in the Java
2946 * programming language.
2947 *
2948 * @param columnIndex the first column is 1, the second 2, ...
2949 * @return the column value; if the value is a SQL <code>NULL</code> the
2950 * value returned is <code>null</code>
2951 * @throws SQLException if the columnIndex is not valid;
2952 * if a database access error occurs
2953 * or this method is called on a closed result set
2954 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2955 * this method
2956 * @since 1.6
2957 */
2958 RowId getRowId(int columnIndex) throws SQLException;
2959
2960 /**
2961 * Retrieves the value of the designated column in the current row of this
2962 * <code>ResultSet</code> object as a <code>java.sql.RowId</code> object in the Java
2963 * programming language.
2964 *
2965 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2966 * @return the column value ; if the value is a SQL <code>NULL</code> the
2967 * value returned is <code>null</code>
2968 * @throws SQLException if the columnLabel is not valid;
2969 * if a database access error occurs
2970 * or this method is called on a closed result set
2971 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2972 * this method
2973 * @since 1.6
2974 */
2975 RowId getRowId(String columnLabel) throws SQLException;
2976
2977 /**
2978 * Updates the designated column with a <code>RowId</code> value. The updater
2979 * methods are used to update column values in the current row or the insert
2980 * row. The updater methods do not update the underlying database; instead
2981 * the <code>updateRow</code> or <code>insertRow</code> methods are called
2982 * to update the database.
2983 *
2984 * @param columnIndex the first column is 1, the second 2, ...
2985 * @param x the column value
2986 * @exception SQLException if the columnIndex is not valid;
2987 * if a database access error occurs;
2988 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2989 * or this method is called on a closed result set
2990 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2991 * this method
2992 * @since 1.6
2993 */
2994 void updateRowId(int columnIndex, RowId x) throws SQLException;
2995
2996 /**
2997 * Updates the designated column with a <code>RowId</code> value. The updater
2998 * methods are used to update column values in the current row or the insert
2999 * row. The updater methods do not update the underlying database; instead
3000 * the <code>updateRow</code> or <code>insertRow</code> methods are called
3001 * to update the database.
3002 *
3003 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3004 * @param x the column value
3005 * @exception SQLException if the columnLabel is not valid;
3006 * if a database access error occurs;
3007 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3008 * or this method is called on a closed result set
3009 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3010 * this method
3011 * @since 1.6
3012 */
3013 void updateRowId(String columnLabel, RowId x) throws SQLException;
3014
3015 /**
3016 * Retrieves the holdability of this <code>ResultSet</code> object
3017 * @return either <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code>
3018 * @throws SQLException if a database access error occurs
3019 * or this method is called on a closed result set
3020 * @since 1.6
3021 */
3022 int getHoldability() throws SQLException;
3023
3024 /**
3025 * Retrieves whether this <code>ResultSet</code> object has been closed. A <code>ResultSet</code> is closed if the
3026 * method close has been called on it, or if it is automatically closed.
3027 *
3028 * @return true if this <code>ResultSet</code> object is closed; false if it is still open
3029 * @throws SQLException if a database access error occurs
3030 * @since 1.6
3031 */
3032 boolean isClosed() throws SQLException;
3033
3034 /**
3035 * Updates the designated column with a <code>String</code> value.
3036 * It is intended for use when updating <code>NCHAR</code>,<code>NVARCHAR</code>
3037 * and <code>LONGNVARCHAR</code> columns.
3038 * The updater methods are used to update column values in the
3039 * current row or the insert row. The updater methods do not
3040 * update the underlying database; instead the <code>updateRow</code> or
3041 * <code>insertRow</code> methods are called to update the database.
3042 *
3043 * @param columnIndex the first column is 1, the second 2, ...
3044 * @param nString the value for the column to be updated
3045 * @throws SQLException if the columnIndex is not valid;
3046 * if the driver does not support national
3047 * character sets; if the driver can detect that a data conversion
3048 * error could occur; this method is called on a closed result set;
3049 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3050 * or if a database access error occurs
3051 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3052 * this method
3053 * @since 1.6
3054 */
3055 void updateNString(int columnIndex, String nString) throws SQLException;
3056
3057 /**
3058 * Updates the designated column with a <code>String</code> value.
3059 * It is intended for use when updating <code>NCHAR</code>,<code>NVARCHAR</code>
3060 * and <code>LONGNVARCHAR</code> columns.
3061 * The updater methods are used to update column values in the
3062 * current row or the insert row. The updater methods do not
3063 * update the underlying database; instead the <code>updateRow</code> or
3064 * <code>insertRow</code> methods are called to update the database.
3065 *
3066 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3067 * @param nString the value for the column to be updated
3068 * @throws SQLException if the columnLabel is not valid;
3069 * if the driver does not support national
3070 * character sets; if the driver can detect that a data conversion
3071 * error could occur; this method is called on a closed result set;
3072 * the result set concurrency is <CODE>CONCUR_READ_ONLY</code>
3073 * or if a database access error occurs
3074 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3075 * this method
3076 * @since 1.6
3077 */
3078 void updateNString(String columnLabel, String nString) throws SQLException;
3079
3080 /**
3081 * Updates the designated column with a <code>java.sql.NClob</code> value.
3082 * The updater methods are used to update column values in the
3083 * current row or the insert row. The updater methods do not
3084 * update the underlying database; instead the <code>updateRow</code> or
3085 * <code>insertRow</code> methods are called to update the database.
3086 *
3087 * @param columnIndex the first column is 1, the second 2, ...
3088 * @param nClob the value for the column to be updated
3089 * @throws SQLException if the columnIndex is not valid;
3090 * if the driver does not support national
3091 * character sets; if the driver can detect that a data conversion
3092 * error could occur; this method is called on a closed result set;
3093 * if a database access error occurs or
3094 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3095 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3096 * this method
3097 * @since 1.6
3098 */
3099 void updateNClob(int columnIndex, NClob nClob) throws SQLException;
3100
3101 /**
3102 * Updates the designated column with a <code>java.sql.NClob</code> value.
3103 * The updater methods are used to update column values in the
3104 * current row or the insert row. The updater methods do not
3105 * update the underlying database; instead the <code>updateRow</code> or
3106 * <code>insertRow</code> methods are called to update the database.
3107 *
3108 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3109 * @param nClob the value for the column to be updated
3110 * @throws SQLException if the columnLabel is not valid;
3111 * if the driver does not support national
3112 * character sets; if the driver can detect that a data conversion
3113 * error could occur; this method is called on a closed result set;
3114 * if a database access error occurs or
3115 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3116 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3117 * this method
3118 * @since 1.6
3119 */
3120 void updateNClob(String columnLabel, NClob nClob) throws SQLException;
3121
3122 /**
3123 * Retrieves the value of the designated column in the current row
3124 * of this <code>ResultSet</code> object as a <code>NClob</code> object
3125 * in the Java programming language.
3126 *
3127 * @param columnIndex the first column is 1, the second is 2, ...
3128 * @return a <code>NClob</code> object representing the SQL
3129 * <code>NCLOB</code> value in the specified column
3130 * @exception SQLException if the columnIndex is not valid;
3131 * if the driver does not support national
3132 * character sets; if the driver can detect that a data conversion
3133 * error could occur; this method is called on a closed result set
3134 * or if a database access error occurs
3135 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3136 * this method
3137 * @since 1.6
3138 */
3139 NClob getNClob(int columnIndex) throws SQLException;
3140
3141 /**
3142 * Retrieves the value of the designated column in the current row
3143 * of this <code>ResultSet</code> object as a <code>NClob</code> object
3144 * in the Java programming language.
3145 *
3146 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3147 * @return a <code>NClob</code> object representing the SQL <code>NCLOB</code>
3148 * value in the specified column
3149 * @exception SQLException if the columnLabel is not valid;
3150 * if the driver does not support national
3151 * character sets; if the driver can detect that a data conversion
3152 * error could occur; this method is called on a closed result set
3153 * or if a database access error occurs
3154 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3155 * this method
3156 * @since 1.6
3157 */
3158 NClob getNClob(String columnLabel) throws SQLException;
3159
3160 /**
3161 * Retrieves the value of the designated column in the current row of
3162 * this <code>ResultSet</code> as a
3163 * <code>java.sql.SQLXML</code> object in the Java programming language.
3164 * @param columnIndex the first column is 1, the second is 2, ...
3165 * @return a <code>SQLXML</code> object that maps an <code>SQL XML</code> value
3166 * @throws SQLException if the columnIndex is not valid;
3167 * if a database access error occurs
3168 * or this method is called on a closed result set
3169 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3170 * this method
3171 * @since 1.6
3172 */
3173 SQLXML getSQLXML(int columnIndex) throws SQLException;
3174
3175 /**
3176 * Retrieves the value of the designated column in the current row of
3177 * this <code>ResultSet</code> as a
3178 * <code>java.sql.SQLXML</code> object in the Java programming language.
3179 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3180 * @return a <code>SQLXML</code> object that maps an <code>SQL XML</code> value
3181 * @throws SQLException if the columnLabel is not valid;
3182 * if a database access error occurs
3183 * or this method is called on a closed result set
3184 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3185 * this method
3186 * @since 1.6
3187 */
3188 SQLXML getSQLXML(String columnLabel) throws SQLException;
3189 /**
3190 * Updates the designated column with a <code>java.sql.SQLXML</code> value.
3191 * The updater
3192 * methods are used to update column values in the current row or the insert
3193 * row. The updater methods do not update the underlying database; instead
3194 * the <code>updateRow</code> or <code>insertRow</code> methods are called
3195 * to update the database.
3196 * <p>
3197 *
3198 * @param columnIndex the first column is 1, the second 2, ...
3199 * @param xmlObject the value for the column to be updated
3200 * @throws SQLException if the columnIndex is not valid;
3201 * if a database access error occurs; this method
3202 * is called on a closed result set;
3203 * the <code>java.xml.transform.Result</code>,
3204 * <code>Writer</code> or <code>OutputStream</code> has not been closed
3205 * for the <code>SQLXML</code> object;
3206 * if there is an error processing the XML value or
3207 * the result set concurrency is <code>CONCUR_READ_ONLY</code>. The <code>getCause</code> method
3208 * of the exception may provide a more detailed exception, for example, if the
3209 * stream does not contain valid XML.
3210 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3211 * this method
3212 * @since 1.6
3213 */
3214 void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException;
3215 /**
3216 * Updates the designated column with a <code>java.sql.SQLXML</code> value.
3217 * The updater
3218 * methods are used to update column values in the current row or the insert
3219 * row. The updater methods do not update the underlying database; instead
3220 * the <code>updateRow</code> or <code>insertRow</code> methods are called
3221 * to update the database.
3222 * <p>
3223 *
3224 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3225 * @param xmlObject the column value
3226 * @throws SQLException if the columnLabel is not valid;
3227 * if a database access error occurs; this method
3228 * is called on a closed result set;
3229 * the <code>java.xml.transform.Result</code>,
3230 * <code>Writer</code> or <code>OutputStream</code> has not been closed
3231 * for the <code>SQLXML</code> object;
3232 * if there is an error processing the XML value or
3233 * the result set concurrency is <code>CONCUR_READ_ONLY</code>. The <code>getCause</code> method
3234 * of the exception may provide a more detailed exception, for example, if the
3235 * stream does not contain valid XML.
3236 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3237 * this method
3238 * @since 1.6
3239 */
3240 void updateSQLXML(String columnLabel, SQLXML xmlObject) throws SQLException;
3241
3242 /**
3243 * Retrieves the value of the designated column in the current row
3244 * of this <code>ResultSet</code> object as
3245 * a <code>String</code> in the Java programming language.
3246 * It is intended for use when
3247 * accessing <code>NCHAR</code>,<code>NVARCHAR</code>
3248 * and <code>LONGNVARCHAR</code> columns.
3249 *
3250 * @param columnIndex the first column is 1, the second is 2, ...
3251 * @return the column value; if the value is SQL <code>NULL</code>, the
3252 * value returned is <code>null</code>
3253 * @exception SQLException if the columnIndex is not valid;
3254 * if a database access error occurs
3255 * or this method is called on a closed result set
3256 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3257 * this method
3258 * @since 1.6
3259 */
3260 String getNString(int columnIndex) throws SQLException;
3261
3262
3263 /**
3264 * Retrieves the value of the designated column in the current row
3265 * of this <code>ResultSet</code> object as
3266 * a <code>String</code> in the Java programming language.
3267 * It is intended for use when
3268 * accessing <code>NCHAR</code>,<code>NVARCHAR</code>
3269 * and <code>LONGNVARCHAR</code> columns.
3270 *
3271 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3272 * @return the column value; if the value is SQL <code>NULL</code>, the
3273 * value returned is <code>null</code>
3274 * @exception SQLException if the columnLabel is not valid;
3275 * if a database access error occurs
3276 * or this method is called on a closed result set
3277 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3278 * this method
3279 * @since 1.6
3280 */
3281 String getNString(String columnLabel) throws SQLException;
3282
3283
3284 /**
3285 * Retrieves the value of the designated column in the current row
3286 * of this <code>ResultSet</code> object as a
3287 * <code>java.io.Reader</code> object.
3288 * It is intended for use when
3289 * accessing <code>NCHAR</code>,<code>NVARCHAR</code>
3290 * and <code>LONGNVARCHAR</code> columns.
3291 *
3292 * @return a <code>java.io.Reader</code> object that contains the column
3293 * value; if the value is SQL <code>NULL</code>, the value returned is
3294 * <code>null</code> in the Java programming language.
3295 * @param columnIndex the first column is 1, the second is 2, ...
3296 * @exception SQLException if the columnIndex is not valid;
3297 * if a database access error occurs
3298 * or this method is called on a closed result set
3299 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3300 * this method
3301 * @since 1.6
3302 */
3303 java.io.Reader getNCharacterStream(int columnIndex) throws SQLException;
3304
3305 /**
3306 * Retrieves the value of the designated column in the current row
3307 * of this <code>ResultSet</code> object as a
3308 * <code>java.io.Reader</code> object.
3309 * It is intended for use when
3310 * accessing <code>NCHAR</code>,<code>NVARCHAR</code>
3311 * and <code>LONGNVARCHAR</code> columns.
3312 *
3313 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3314 * @return a <code>java.io.Reader</code> object that contains the column
3315 * value; if the value is SQL <code>NULL</code>, the value returned is
3316 * <code>null</code> in the Java programming language
3317 * @exception SQLException if the columnLabel is not valid;
3318 * if a database access error occurs
3319 * or this method is called on a closed result set
3320 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3321 * this method
3322 * @since 1.6
3323 */
3324 java.io.Reader getNCharacterStream(String columnLabel) throws SQLException;
3325
3326 /**
3327 * Updates the designated column with a character stream value, which will have
3328 * the specified number of bytes. The
3329 * driver does the necessary conversion from Java character format to
3330 * the national character set in the database.
3331 * It is intended for use when
3332 * updating <code>NCHAR</code>,<code>NVARCHAR</code>
3333 * and <code>LONGNVARCHAR</code> columns.
3334 * <p>
3335 * The updater methods are used to update column values in the
3336 * current row or the insert row. The updater methods do not
3337 * update the underlying database; instead the <code>updateRow</code> or
3338 * <code>insertRow</code> methods are called to update the database.
3339 *
3340 * @param columnIndex the first column is 1, the second is 2, ...
3341 * @param x the new column value
3342 * @param length the length of the stream
3343 * @exception SQLException if the columnIndex is not valid;
3344 * if a database access error occurs;
3345 * the result set concurrency is <code>CONCUR_READ_ONLY</code> or this method is called on a closed result set
3346 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3347 * this method
3348 * @since 1.6
3349 */
3350 void updateNCharacterStream(int columnIndex,
3351 java.io.Reader x,
3352 long length) throws SQLException;
3353
3354 /**
3355 * Updates the designated column with a character stream value, which will have
3356 * the specified number of bytes. The
3357 * driver does the necessary conversion from Java character format to
3358 * the national character set in the database.
3359 * It is intended for use when
3360 * updating <code>NCHAR</code>,<code>NVARCHAR</code>
3361 * and <code>LONGNVARCHAR</code> columns.
3362 * <p>
3363 * The updater methods are used to update column values in the
3364 * current row or the insert row. The updater methods do not
3365 * update the underlying database; instead the <code>updateRow</code> or
3366 * <code>insertRow</code> methods are called to update the database.
3367 *
3368 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3369 * @param reader the <code>java.io.Reader</code> object containing
3370 * the new column value
3371 * @param length the length of the stream
3372 * @exception SQLException if the columnLabel is not valid;
3373 * if a database access error occurs;
3374 * the result set concurrency is <code>CONCUR_READ_ONLY</code> or this method is called on a closed result set
3375 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3376 * this method
3377 * @since 1.6
3378 */
3379 void updateNCharacterStream(String columnLabel,
3380 java.io.Reader reader,
3381 long length) throws SQLException;
3382 /**
3383 * Updates the designated column with an ascii stream value, which will have
3384 * the specified number of bytes.
3385 * <p>
3386 * The updater methods are used to update column values in the
3387 * current row or the insert row. The updater methods do not
3388 * update the underlying database; instead the <code>updateRow</code> or
3389 * <code>insertRow</code> methods are called to update the database.
3390 *
3391 * @param columnIndex the first column is 1, the second is 2, ...
3392 * @param x the new column value
3393 * @param length the length of the stream
3394 * @exception SQLException if the columnIndex is not valid;
3395 * if a database access error occurs;
3396 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3397 * or this method is called on a closed result set
3398 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3399 * this method
3400 * @since 1.6
3401 */
3402 void updateAsciiStream(int columnIndex,
3403 java.io.InputStream x,
3404 long length) throws SQLException;
3405
3406 /**
3407 * Updates the designated column with a binary stream value, which will have
3408 * the specified number of bytes.
3409 * <p>
3410 * The updater methods are used to update column values in the
3411 * current row or the insert row. The updater methods do not
3412 * update the underlying database; instead the <code>updateRow</code> or
3413 * <code>insertRow</code> methods are called to update the database.
3414 *
3415 * @param columnIndex the first column is 1, the second is 2, ...
3416 * @param x the new column value
3417 * @param length the length of the stream
3418 * @exception SQLException if the columnIndex is not valid;
3419 * if a database access error occurs;
3420 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3421 * or this method is called on a closed result set
3422 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3423 * this method
3424 * @since 1.6
3425 */
3426 void updateBinaryStream(int columnIndex,
3427 java.io.InputStream x,
3428 long length) throws SQLException;
3429
3430 /**
3431 * Updates the designated column with a character stream value, which will have
3432 * the specified number of bytes.
3433 * <p>
3434 * The updater methods are used to update column values in the
3435 * current row or the insert row. The updater methods do not
3436 * update the underlying database; instead the <code>updateRow</code> or
3437 * <code>insertRow</code> methods are called to update the database.
3438 *
3439 * @param columnIndex the first column is 1, the second is 2, ...
3440 * @param x the new column value
3441 * @param length the length of the stream
3442 * @exception SQLException if the columnIndex is not valid;
3443 * if a database access error occurs;
3444 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3445 * or this method is called on a closed result set
3446 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3447 * this method
3448 * @since 1.6
3449 */
3450 void updateCharacterStream(int columnIndex,
3451 java.io.Reader x,
3452 long length) throws SQLException;
3453 /**
3454 * Updates the designated column with an ascii stream value, which will have
3455 * the specified number of bytes.
3456 * <p>
3457 * The updater methods are used to update column values in the
3458 * current row or the insert row. The updater methods do not
3459 * update the underlying database; instead the <code>updateRow</code> or
3460 * <code>insertRow</code> methods are called to update the database.
3461 *
3462 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3463 * @param x the new column value
3464 * @param length the length of the stream
3465 * @exception SQLException if the columnLabel is not valid;
3466 * if a database access error occurs;
3467 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3468 * or this method is called on a closed result set
3469 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3470 * this method
3471 * @since 1.6
3472 */
3473 void updateAsciiStream(String columnLabel,
3474 java.io.InputStream x,
3475 long length) throws SQLException;
3476
3477 /**
3478 * Updates the designated column with a binary stream value, which will have
3479 * the specified number of bytes.
3480 * <p>
3481 * The updater methods are used to update column values in the
3482 * current row or the insert row. The updater methods do not
3483 * update the underlying database; instead the <code>updateRow</code> or
3484 * <code>insertRow</code> methods are called to update the database.
3485 *
3486 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3487 * @param x the new column value
3488 * @param length the length of the stream
3489 * @exception SQLException if the columnLabel is not valid;
3490 * if a database access error occurs;
3491 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3492 * or this method is called on a closed result set
3493 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3494 * this method
3495 * @since 1.6
3496 */
3497 void updateBinaryStream(String columnLabel,
3498 java.io.InputStream x,
3499 long length) throws SQLException;
3500
3501 /**
3502 * Updates the designated column with a character stream value, which will have
3503 * the specified number of bytes.
3504 * <p>
3505 * The updater methods are used to update column values in the
3506 * current row or the insert row. The updater methods do not
3507 * update the underlying database; instead the <code>updateRow</code> or
3508 * <code>insertRow</code> methods are called to update the database.
3509 *
3510 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3511 * @param reader the <code>java.io.Reader</code> object containing
3512 * the new column value
3513 * @param length the length of the stream
3514 * @exception SQLException if the columnLabel is not valid;
3515 * if a database access error occurs;
3516 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3517 * or this method is called on a closed result set
3518 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3519 * this method
3520 * @since 1.6
3521 */
3522 void updateCharacterStream(String columnLabel,
3523 java.io.Reader reader,
3524 long length) throws SQLException;
3525 /**
3526 * Updates the designated column using the given input stream, which
3527 * will have the specified number of bytes.
3528 *
3529 * <p>
3530 * The updater methods are used to update column values in the
3531 * current row or the insert row. The updater methods do not
3532 * update the underlying database; instead the <code>updateRow</code> or
3533 * <code>insertRow</code> methods are called to update the database.
3534 *
3535 * @param columnIndex the first column is 1, the second is 2, ...
3536 * @param inputStream An object that contains the data to set the parameter
3537 * value to.
3538 * @param length the number of bytes in the parameter data.
3539 * @exception SQLException if the columnIndex is not valid;
3540 * if a database access error occurs;
3541 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3542 * or this method is called on a closed result set
3543 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3544 * this method
3545 * @since 1.6
3546 */
3547 void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException;
3548
3549 /**
3550 * Updates the designated column using the given input stream, which
3551 * will have the specified number of bytes.
3552 *
3553 * <p>
3554 * The updater methods are used to update column values in the
3555 * current row or the insert row. The updater methods do not
3556 * update the underlying database; instead the <code>updateRow</code> or
3557 * <code>insertRow</code> methods are called to update the database.
3558 *
3559 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3560 * @param inputStream An object that contains the data to set the parameter
3561 * value to.
3562 * @param length the number of bytes in the parameter data.
3563 * @exception SQLException if the columnLabel is not valid;
3564 * if a database access error occurs;
3565 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3566 * or this method is called on a closed result set
3567 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3568 * this method
3569 * @since 1.6
3570 */
3571 void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException;
3572
3573 /**
3574 * Updates the designated column using the given <code>Reader</code>
3575 * object, which is the given number of characters long.
3576 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
3577 * parameter, it may be more practical to send it via a
3578 * <code>java.io.Reader</code> object. The JDBC driver will
3579 * do any necessary conversion from UNICODE to the database char format.
3580 *
3581 * <p>
3582 * The updater methods are used to update column values in the
3583 * current row or the insert row. The updater methods do not
3584 * update the underlying database; instead the <code>updateRow</code> or
3585 * <code>insertRow</code> methods are called to update the database.
3586 *
3587 * @param columnIndex the first column is 1, the second is 2, ...
3588 * @param reader An object that contains the data to set the parameter value to.
3589 * @param length the number of characters in the parameter data.
3590 * @exception SQLException if the columnIndex is not valid;
3591 * if a database access error occurs;
3592 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3593 * or this method is called on a closed result set
3594 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3595 * this method
3596 * @since 1.6
3597 */
3598 void updateClob(int columnIndex, Reader reader, long length) throws SQLException;
3599
3600 /**
3601 * Updates the designated column using the given <code>Reader</code>
3602 * object, which is the given number of characters long.
3603 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
3604 * parameter, it may be more practical to send it via a
3605 * <code>java.io.Reader</code> object. The JDBC driver will
3606 * do any necessary conversion from UNICODE to the database char format.
3607 *
3608 * <p>
3609 * The updater methods are used to update column values in the
3610 * current row or the insert row. The updater methods do not
3611 * update the underlying database; instead the <code>updateRow</code> or
3612 * <code>insertRow</code> methods are called to update the database.
3613 *
3614 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3615 * @param reader An object that contains the data to set the parameter value to.
3616 * @param length the number of characters in the parameter data.
3617 * @exception SQLException if the columnLabel is not valid;
3618 * if a database access error occurs;
3619 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3620 * or this method is called on a closed result set
3621 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3622 * this method
3623 * @since 1.6
3624 */
3625 void updateClob(String columnLabel, Reader reader, long length) throws SQLException;
3626 /**
3627 * Updates the designated column using the given <code>Reader</code>
3628 * object, which is the given number of characters long.
3629 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
3630 * parameter, it may be more practical to send it via a
3631 * <code>java.io.Reader</code> object. The JDBC driver will
3632 * do any necessary conversion from UNICODE to the database char format.
3633 *
3634 * <p>
3635 * The updater methods are used to update column values in the
3636 * current row or the insert row. The updater methods do not
3637 * update the underlying database; instead the <code>updateRow</code> or
3638 * <code>insertRow</code> methods are called to update the database.
3639 *
3640 * @param columnIndex the first column is 1, the second 2, ...
3641 * @param reader An object that contains the data to set the parameter value to.
3642 * @param length the number of characters in the parameter data.
3643 * @throws SQLException if the columnIndex is not valid;
3644 * if the driver does not support national
3645 * character sets; if the driver can detect that a data conversion
3646 * error could occur; this method is called on a closed result set,
3647 * if a database access error occurs or
3648 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3649 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3650 * this method
3651 * @since 1.6
3652 */
3653 void updateNClob(int columnIndex, Reader reader, long length) throws SQLException;
3654
3655 /**
3656 * Updates the designated column using the given <code>Reader</code>
3657 * object, which is the given number of characters long.
3658 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
3659 * parameter, it may be more practical to send it via a
3660 * <code>java.io.Reader</code> object. The JDBC driver will
3661 * do any necessary conversion from UNICODE to the database char format.
3662 *
3663 * <p>
3664 * The updater methods are used to update column values in the
3665 * current row or the insert row. The updater methods do not
3666 * update the underlying database; instead the <code>updateRow</code> or
3667 * <code>insertRow</code> methods are called to update the database.
3668 *
3669 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3670 * @param reader An object that contains the data to set the parameter value to.
3671 * @param length the number of characters in the parameter data.
3672 * @throws SQLException if the columnLabel is not valid;
3673 * if the driver does not support national
3674 * character sets; if the driver can detect that a data conversion
3675 * error could occur; this method is called on a closed result set;
3676 * if a database access error occurs or
3677 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3678 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3679 * this method
3680 * @since 1.6
3681 */
3682 void updateNClob(String columnLabel, Reader reader, long length) throws SQLException;
3683
3684 //---
3685
3686 /**
3687 * Updates the designated column with a character stream value.
3688 * The data will be read from the stream
3689 * as needed until end-of-stream is reached. The
3690 * driver does the necessary conversion from Java character format to
3691 * the national character set in the database.
3692 * It is intended for use when
3693 * updating <code>NCHAR</code>,<code>NVARCHAR</code>
3694 * and <code>LONGNVARCHAR</code> columns.
3695 * <p>
3696 * The updater methods are used to update column values in the
3697 * current row or the insert row. The updater methods do not
3698 * update the underlying database; instead the <code>updateRow</code> or
3699 * <code>insertRow</code> methods are called to update the database.
3700 *
3701 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3702 * it might be more efficient to use a version of
3703 * <code>updateNCharacterStream</code> which takes a length parameter.
3704 *
3705 * @param columnIndex the first column is 1, the second is 2, ...
3706 * @param x the new column value
3707 * @exception SQLException if the columnIndex is not valid;
3708 * if a database access error occurs;
3709 * the result set concurrency is <code>CONCUR_READ_ONLY</code> or this method is called on a closed result set
3710 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3711 * this method
3712 * @since 1.6
3713 */
3714 void updateNCharacterStream(int columnIndex,
3715 java.io.Reader x) throws SQLException;
3716
3717 /**
3718 * Updates the designated column with a character stream value.
3719 * The data will be read from the stream
3720 * as needed until end-of-stream is reached. The
3721 * driver does the necessary conversion from Java character format to
3722 * the national character set in the database.
3723 * It is intended for use when
3724 * updating <code>NCHAR</code>,<code>NVARCHAR</code>
3725 * and <code>LONGNVARCHAR</code> columns.
3726 * <p>
3727 * The updater methods are used to update column values in the
3728 * current row or the insert row. The updater methods do not
3729 * update the underlying database; instead the <code>updateRow</code> or
3730 * <code>insertRow</code> methods are called to update the database.
3731 *
3732 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3733 * it might be more efficient to use a version of
3734 * <code>updateNCharacterStream</code> which takes a length parameter.
3735 *
3736 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3737 * @param reader the <code>java.io.Reader</code> object containing
3738 * the new column value
3739 * @exception SQLException if the columnLabel is not valid;
3740 * if a database access error occurs;
3741 * the result set concurrency is <code>CONCUR_READ_ONLY</code> or this method is called on a closed result set
3742 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3743 * this method
3744 * @since 1.6
3745 */
3746 void updateNCharacterStream(String columnLabel,
3747 java.io.Reader reader) throws SQLException;
3748 /**
3749 * Updates the designated column with an ascii stream value.
3750 * The data will be read from the stream
3751 * as needed until end-of-stream is reached.
3752 * <p>
3753 * The updater methods are used to update column values in the
3754 * current row or the insert row. The updater methods do not
3755 * update the underlying database; instead the <code>updateRow</code> or
3756 * <code>insertRow</code> methods are called to update the database.
3757 *
3758 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3759 * it might be more efficient to use a version of
3760 * <code>updateAsciiStream</code> which takes a length parameter.
3761 *
3762 * @param columnIndex the first column is 1, the second is 2, ...
3763 * @param x the new column value
3764 * @exception SQLException if the columnIndex is not valid;
3765 * if a database access error occurs;
3766 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3767 * or this method is called on a closed result set
3768 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3769 * this method
3770 * @since 1.6
3771 */
3772 void updateAsciiStream(int columnIndex,
3773 java.io.InputStream x) throws SQLException;
3774
3775 /**
3776 * Updates the designated column with a binary stream value.
3777 * The data will be read from the stream
3778 * as needed until end-of-stream is reached.
3779 * <p>
3780 * The updater methods are used to update column values in the
3781 * current row or the insert row. The updater methods do not
3782 * update the underlying database; instead the <code>updateRow</code> or
3783 * <code>insertRow</code> methods are called to update the database.
3784 *
3785 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3786 * it might be more efficient to use a version of
3787 * <code>updateBinaryStream</code> which takes a length parameter.
3788 *
3789 * @param columnIndex the first column is 1, the second is 2, ...
3790 * @param x the new column value
3791 * @exception SQLException if the columnIndex is not valid;
3792 * if a database access error occurs;
3793 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3794 * or this method is called on a closed result set
3795 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3796 * this method
3797 * @since 1.6
3798 */
3799 void updateBinaryStream(int columnIndex,
3800 java.io.InputStream x) throws SQLException;
3801
3802 /**
3803 * Updates the designated column with a character stream value.
3804 * The data will be read from the stream
3805 * as needed until end-of-stream is reached.
3806 * <p>
3807 * The updater methods are used to update column values in the
3808 * current row or the insert row. The updater methods do not
3809 * update the underlying database; instead the <code>updateRow</code> or
3810 * <code>insertRow</code> methods are called to update the database.
3811 *
3812 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3813 * it might be more efficient to use a version of
3814 * <code>updateCharacterStream</code> which takes a length parameter.
3815 *
3816 * @param columnIndex the first column is 1, the second is 2, ...
3817 * @param x the new column value
3818 * @exception SQLException if the columnIndex is not valid;
3819 * if a database access error occurs;
3820 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3821 * or this method is called on a closed result set
3822 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3823 * this method
3824 * @since 1.6
3825 */
3826 void updateCharacterStream(int columnIndex,
3827 java.io.Reader x) throws SQLException;
3828 /**
3829 * Updates the designated column with an ascii stream value.
3830 * The data will be read from the stream
3831 * as needed until end-of-stream is reached.
3832 * <p>
3833 * The updater methods are used to update column values in the
3834 * current row or the insert row. The updater methods do not
3835 * update the underlying database; instead the <code>updateRow</code> or
3836 * <code>insertRow</code> methods are called to update the database.
3837 *
3838 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3839 * it might be more efficient to use a version of
3840 * <code>updateAsciiStream</code> which takes a length parameter.
3841 *
3842 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3843 * @param x the new column value
3844 * @exception SQLException if the columnLabel is not valid;
3845 * if a database access error occurs;
3846 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3847 * or this method is called on a closed result set
3848 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3849 * this method
3850 * @since 1.6
3851 */
3852 void updateAsciiStream(String columnLabel,
3853 java.io.InputStream x) throws SQLException;
3854
3855 /**
3856 * Updates the designated column with a binary stream value.
3857 * The data will be read from the stream
3858 * as needed until end-of-stream is reached.
3859 * <p>
3860 * The updater methods are used to update column values in the
3861 * current row or the insert row. The updater methods do not
3862 * update the underlying database; instead the <code>updateRow</code> or
3863 * <code>insertRow</code> methods are called to update the database.
3864 *
3865 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3866 * it might be more efficient to use a version of
3867 * <code>updateBinaryStream</code> which takes a length parameter.
3868 *
3869 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3870 * @param x the new column value
3871 * @exception SQLException if the columnLabel is not valid;
3872 * if a database access error occurs;
3873 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3874 * or this method is called on a closed result set
3875 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3876 * this method
3877 * @since 1.6
3878 */
3879 void updateBinaryStream(String columnLabel,
3880 java.io.InputStream x) throws SQLException;
3881
3882 /**
3883 * Updates the designated column with a character stream value.
3884 * The data will be read from the stream
3885 * as needed until end-of-stream is reached.
3886 * <p>
3887 * The updater methods are used to update column values in the
3888 * current row or the insert row. The updater methods do not
3889 * update the underlying database; instead the <code>updateRow</code> or
3890 * <code>insertRow</code> methods are called to update the database.
3891 *
3892 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3893 * it might be more efficient to use a version of
3894 * <code>updateCharacterStream</code> which takes a length parameter.
3895 *
3896 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3897 * @param reader the <code>java.io.Reader</code> object containing
3898 * the new column value
3899 * @exception SQLException if the columnLabel is not valid; if a database access error occurs;
3900 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3901 * or this method is called on a closed result set
3902 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3903 * this method
3904 * @since 1.6
3905 */
3906 void updateCharacterStream(String columnLabel,
3907 java.io.Reader reader) throws SQLException;
3908 /**
3909 * Updates the designated column using the given input stream. The data will be read from the stream
3910 * as needed until end-of-stream is reached.
3911 * <p>
3912 * The updater methods are used to update column values in the
3913 * current row or the insert row. The updater methods do not
3914 * update the underlying database; instead the <code>updateRow</code> or
3915 * <code>insertRow</code> methods are called to update the database.
3916 *
3917 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3918 * it might be more efficient to use a version of
3919 * <code>updateBlob</code> which takes a length parameter.
3920 *
3921 * @param columnIndex the first column is 1, the second is 2, ...
3922 * @param inputStream An object that contains the data to set the parameter
3923 * value to.
3924 * @exception SQLException if the columnIndex is not valid; if a database access error occurs;
3925 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3926 * or this method is called on a closed result set
3927 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3928 * this method
3929 * @since 1.6
3930 */
3931 void updateBlob(int columnIndex, InputStream inputStream) throws SQLException;
3932
3933 /**
3934 * Updates the designated column using the given input stream. The data will be read from the stream
3935 * as needed until end-of-stream is reached.
3936 * <p>
3937 * The updater methods are used to update column values in the
3938 * current row or the insert row. The updater methods do not
3939 * update the underlying database; instead the <code>updateRow</code> or
3940 * <code>insertRow</code> methods are called to update the database.
3941 *
3942 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3943 * it might be more efficient to use a version of
3944 * <code>updateBlob</code> which takes a length parameter.
3945 *
3946 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3947 * @param inputStream An object that contains the data to set the parameter
3948 * value to.
3949 * @exception SQLException if the columnLabel is not valid; if a database access error occurs;
3950 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3951 * or this method is called on a closed result set
3952 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3953 * this method
3954 * @since 1.6
3955 */
3956 void updateBlob(String columnLabel, InputStream inputStream) throws SQLException;
3957
3958 /**
3959 * Updates the designated column using the given <code>Reader</code>
3960 * object.
3961 * The data will be read from the stream
3962 * as needed until end-of-stream is reached. The JDBC driver will
3963 * do any necessary conversion from UNICODE to the database char format.
3964 *
3965 * <p>
3966 * The updater methods are used to update column values in the
3967 * current row or the insert row. The updater methods do not
3968 * update the underlying database; instead the <code>updateRow</code> or
3969 * <code>insertRow</code> methods are called to update the database.
3970 *
3971 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3972 * it might be more efficient to use a version of
3973 * <code>updateClob</code> which takes a length parameter.
3974 *
3975 * @param columnIndex the first column is 1, the second is 2, ...
3976 * @param reader An object that contains the data to set the parameter value to.
3977 * @exception SQLException if the columnIndex is not valid;
3978 * if a database access error occurs;
3979 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3980 * or this method is called on a closed result set
3981 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3982 * this method
3983 * @since 1.6
3984 */
3985 void updateClob(int columnIndex, Reader reader) throws SQLException;
3986
3987 /**
3988 * Updates the designated column using the given <code>Reader</code>
3989 * object.
3990 * The data will be read from the stream
3991 * as needed until end-of-stream is reached. The JDBC driver will
3992 * do any necessary conversion from UNICODE to the database char format.
3993 *
3994 * <p>
3995 * The updater methods are used to update column values in the
3996 * current row or the insert row. The updater methods do not
3997 * update the underlying database; instead the <code>updateRow</code> or
3998 * <code>insertRow</code> methods are called to update the database.
3999 *
4000 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
4001 * it might be more efficient to use a version of
4002 * <code>updateClob</code> which takes a length parameter.
4003 *
4004 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
4005 * @param reader An object that contains the data to set the parameter value to.
4006 * @exception SQLException if the columnLabel is not valid; if a database access error occurs;
4007 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
4008 * or this method is called on a closed result set
4009 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
4010 * this method
4011 * @since 1.6
4012 */
4013 void updateClob(String columnLabel, Reader reader) throws SQLException;
4014 /**
4015 * Updates the designated column using the given <code>Reader</code>
4016 *
4017 * The data will be read from the stream
4018 * as needed until end-of-stream is reached. The JDBC driver will
4019 * do any necessary conversion from UNICODE to the database char format.
4020 *
4021 * <p>
4022 * The updater methods are used to update column values in the
4023 * current row or the insert row. The updater methods do not
4024 * update the underlying database; instead the <code>updateRow</code> or
4025 * <code>insertRow</code> methods are called to update the database.
4026 *
4027 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
4028 * it might be more efficient to use a version of
4029 * <code>updateNClob</code> which takes a length parameter.
4030 *
4031 * @param columnIndex the first column is 1, the second 2, ...
4032 * @param reader An object that contains the data to set the parameter value to.
4033 * @throws SQLException if the columnIndex is not valid;
4034 * if the driver does not support national
4035 * character sets; if the driver can detect that a data conversion
4036 * error could occur; this method is called on a closed result set,
4037 * if a database access error occurs or
4038 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
4039 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
4040 * this method
4041 * @since 1.6
4042 */
4043 void updateNClob(int columnIndex, Reader reader) throws SQLException;
4044
4045 /**
4046 * Updates the designated column using the given <code>Reader</code>
4047 * object.
4048 * The data will be read from the stream
4049 * as needed until end-of-stream is reached. The JDBC driver will
4050 * do any necessary conversion from UNICODE to the database char format.
4051 *
4052 * <p>
4053 * The updater methods are used to update column values in the
4054 * current row or the insert row. The updater methods do not
4055 * update the underlying database; instead the <code>updateRow</code> or
4056 * <code>insertRow</code> methods are called to update the database.
4057 *
4058 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
4059 * it might be more efficient to use a version of
4060 * <code>updateNClob</code> which takes a length parameter.
4061 *
4062 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
4063 * @param reader An object that contains the data to set the parameter value to.
4064 * @throws SQLException if the columnLabel is not valid; if the driver does not support national
4065 * character sets; if the driver can detect that a data conversion
4066 * error could occur; this method is called on a closed result set;
4067 * if a database access error occurs or
4068 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
4069 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
4070 * this method
4071 * @since 1.6
4072 */
4073 void updateNClob(String columnLabel, Reader reader) throws SQLException;
4074
4075 }
Save This Page