1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46 package groovy.sql;
47
48 import groovy.lang.GroovyObjectSupport;
49 import groovy.lang.MissingPropertyException;
50
51 import java.math.BigDecimal;
52 import java.sql.Array;
53 import java.sql.Blob;
54 import java.sql.Clob;
55 import java.sql.Ref;
56 import java.sql.ResultSet;
57 import java.sql.ResultSetMetaData;
58 import java.sql.SQLException;
59 import java.sql.SQLWarning;
60 import java.sql.Statement;
61 import java.util.Calendar;
62 import java.util.Iterator;
63 import java.util.Map;
64
65 /***
66 * Represents an extent of objects
67 *
68 * @Author Chris Stevenson
69 * @author <a href="mailto:james@coredevelopers.net">James Strachan</a>
70 * @author <a href="mailto:ivan_ganza@yahoo.com">Ivan Ganza</a>
71 * @version $Revision: 1.5 $
72 */
73 public class GroovyResultSet extends GroovyObjectSupport implements ResultSet {
74
75 private ResultSet resultSet;
76 private boolean updated;
77
78 public GroovyResultSet(ResultSet resultSet) {
79 this.resultSet = resultSet;
80 }
81
82 public Object getProperty(String property) {
83 try {
84 return resultSet.getObject(property);
85 }
86 catch (SQLException e) {
87 throw new MissingPropertyException(property, GroovyResultSet.class, e);
88 }
89 }
90
91 public void setProperty(String property, Object newValue) {
92 try {
93 resultSet.updateObject(property, newValue);
94 updated = true;
95 }
96 catch (SQLException e) {
97 throw new MissingPropertyException(property, GroovyResultSet.class, e);
98 }
99 }
100
101 /***
102 * Supports integer based subscript operators for accessing at numbered columns
103 * starting at zero. Negative indices are supported, they will count from the last column backwards.
104 *
105 * @param index is the number of the column to look at starting at 1
106 * @return
107 */
108 public Object getAt(int index) throws SQLException {
109 index = normalizeIndex(index);
110 return resultSet.getObject(index);
111 }
112
113 /***
114 * Supports integer based subscript operators for updating the values of numbered columns
115 * starting at zero. Negative indices are supported, they will count from the last column backwards.
116 *
117 * @param index is the number of the column to look at starting at 1
118 * @return
119 */
120 public void putAt(int index, Object newValue) throws SQLException {
121 index = normalizeIndex(index);
122 resultSet.updateObject(index, newValue);
123 }
124
125 /***
126 * Adds a new row to this result set
127 * @param values
128 */
129 public void add(Map values) throws SQLException {
130 resultSet.moveToInsertRow();
131 for (Iterator iter = values.entrySet().iterator(); iter.hasNext();) {
132 Map.Entry entry = (Map.Entry) iter.next();
133 resultSet.updateObject(entry.getKey().toString(), entry.getValue());
134 }
135 resultSet.insertRow();
136 }
137
138 /***
139 * Takes a zero based index and convert it into an SQL based 1 based index.
140 * A negative index will count backwards from the last column.
141 *
142 * @param index
143 * @return a JDBC index
144 * @throws SQLException if some exception occurs finding out the column count
145 */
146 protected int normalizeIndex(int index) throws SQLException {
147 if (index < 0) {
148 int columnCount = resultSet.getMetaData().getColumnCount();
149 do {
150 index += columnCount;
151 }
152 while (index < 0);
153 }
154 return index + 1;
155 }
156
157
158
159
160 /***
161 * Moves the cursor down one row from its current position.
162 * A <code>ResultSet</code> cursor is initially positioned
163 * before the first row; the first call to the method
164 * <code>next</code> makes the first row the current row; the
165 * second call makes the second row the current row, and so on.
166 *
167 * <P>If an input stream is open for the current row, a call
168 * to the method <code>next</code> will
169 * implicitly close it. A <code>ResultSet</code> object's
170 * warning chain is cleared when a new row is read.
171 *
172 * @return <code>true</code> if the new current row is valid;
173 * <code>false</code> if there are no more rows
174 * @exception SQLException if a database access error occurs
175 */
176 public boolean next() throws SQLException {
177 if (updated) {
178 resultSet.updateRow();
179 updated = false;
180 }
181 return resultSet.next();
182 }
183
184
185 /***
186 * Releases this <code>ResultSet</code> object's database and
187 * JDBC resources immediately instead of waiting for
188 * this to happen when it is automatically closed.
189 *
190 * <P><B>Note:</B> A <code>ResultSet</code> object
191 * is automatically closed by the
192 * <code>Statement</code> object that generated it when
193 * that <code>Statement</code> object is closed,
194 * re-executed, or is used to retrieve the next result from a
195 * sequence of multiple results. A <code>ResultSet</code> object
196 * is also automatically closed when it is garbage collected.
197 *
198 * @exception SQLException if a database access error occurs
199 */
200 public void close() throws SQLException {
201 resultSet.close();
202 }
203
204 /***
205 * Reports whether
206 * the last column read had a value of SQL <code>NULL</code>.
207 * Note that you must first call one of the getter methods
208 * on a column to try to read its value and then call
209 * the method <code>wasNull</code> to see if the value read was
210 * SQL <code>NULL</code>.
211 *
212 * @return <code>true</code> if the last column value read was SQL
213 * <code>NULL</code> and <code>false</code> otherwise
214 * @exception SQLException if a database access error occurs
215 */
216 public boolean wasNull() throws SQLException {
217 return resultSet.wasNull();
218 }
219
220
221
222
223
224 /***
225 * Retrieves the value of the designated column in the current row
226 * of this <code>ResultSet</code> object as
227 * a <code>String</code> in the Java programming language.
228 *
229 * @param columnIndex the first column is 1, the second is 2, ...
230 * @return the column value; if the value is SQL <code>NULL</code>, the
231 * value returned is <code>null</code>
232 * @exception SQLException if a database access error occurs
233 */
234 public String getString(int columnIndex) throws SQLException {
235 return resultSet.getString(columnIndex);
236 }
237
238 /***
239 * Retrieves the value of the designated column in the current row
240 * of this <code>ResultSet</code> object as
241 * a <code>boolean</code> in the Java programming language.
242 *
243 * @param columnIndex the first column is 1, the second is 2, ...
244 * @return the column value; if the value is SQL <code>NULL</code>, the
245 * value returned is <code>false</code>
246 * @exception SQLException if a database access error occurs
247 */
248 public boolean getBoolean(int columnIndex) throws SQLException {
249 return resultSet.getBoolean(columnIndex);
250 }
251
252 /***
253 * Retrieves the value of the designated column in the current row
254 * of this <code>ResultSet</code> object as
255 * a <code>byte</code> in the Java programming language.
256 *
257 * @param columnIndex the first column is 1, the second is 2, ...
258 * @return the column value; if the value is SQL <code>NULL</code>, the
259 * value returned is <code>0</code>
260 * @exception SQLException if a database access error occurs
261 */
262 public byte getByte(int columnIndex) throws SQLException {
263 return resultSet.getByte(columnIndex);
264 }
265
266 /***
267 * Retrieves the value of the designated column in the current row
268 * of this <code>ResultSet</code> object as
269 * a <code>short</code> in the Java programming language.
270 *
271 * @param columnIndex the first column is 1, the second is 2, ...
272 * @return the column value; if the value is SQL <code>NULL</code>, the
273 * value returned is <code>0</code>
274 * @exception SQLException if a database access error occurs
275 */
276 public short getShort(int columnIndex) throws SQLException {
277 return resultSet.getShort(columnIndex);
278 }
279
280 /***
281 * Retrieves the value of the designated column in the current row
282 * of this <code>ResultSet</code> object as
283 * an <code>int</code> in the Java programming language.
284 *
285 * @param columnIndex the first column is 1, the second is 2, ...
286 * @return the column value; if the value is SQL <code>NULL</code>, the
287 * value returned is <code>0</code>
288 * @exception SQLException if a database access error occurs
289 */
290 public int getInt(int columnIndex) throws SQLException {
291 return resultSet.getInt(columnIndex);
292 }
293
294 /***
295 * Retrieves the value of the designated column in the current row
296 * of this <code>ResultSet</code> object as
297 * a <code>long</code> in the Java programming language.
298 *
299 * @param columnIndex the first column is 1, the second is 2, ...
300 * @return the column value; if the value is SQL <code>NULL</code>, the
301 * value returned is <code>0</code>
302 * @exception SQLException if a database access error occurs
303 */
304 public long getLong(int columnIndex) throws SQLException {
305 return resultSet.getLong(columnIndex);
306 }
307
308 /***
309 * Retrieves the value of the designated column in the current row
310 * of this <code>ResultSet</code> object as
311 * a <code>float</code> in the Java programming language.
312 *
313 * @param columnIndex the first column is 1, the second is 2, ...
314 * @return the column value; if the value is SQL <code>NULL</code>, the
315 * value returned is <code>0</code>
316 * @exception SQLException if a database access error occurs
317 */
318 public float getFloat(int columnIndex) throws SQLException {
319 return resultSet.getFloat(columnIndex);
320 }
321
322 /***
323 * Retrieves the value of the designated column in the current row
324 * of this <code>ResultSet</code> object as
325 * a <code>double</code> in the Java programming language.
326 *
327 * @param columnIndex the first column is 1, the second is 2, ...
328 * @return the column value; if the value is SQL <code>NULL</code>, the
329 * value returned is <code>0</code>
330 * @exception SQLException if a database access error occurs
331 */
332 public double getDouble(int columnIndex) throws SQLException {
333 return resultSet.getDouble(columnIndex);
334 }
335
336 /***
337 * Retrieves the value of the designated column in the current row
338 * of this <code>ResultSet</code> object as
339 * a <code>java.sql.BigDecimal</code> in the Java programming language.
340 *
341 * @param columnIndex the first column is 1, the second is 2, ...
342 * @param scale the number of digits to the right of the decimal point
343 * @return the column value; if the value is SQL <code>NULL</code>, the
344 * value returned is <code>null</code>
345 * @exception SQLException if a database access error occurs
346 * @deprecated
347 */
348 public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
349 return resultSet.getBigDecimal(columnIndex, scale);
350 }
351
352 /***
353 * Retrieves the value of the designated column in the current row
354 * of this <code>ResultSet</code> object as
355 * a <code>byte</code> array in the Java programming language.
356 * The bytes represent the raw values returned by the driver.
357 *
358 * @param columnIndex the first column is 1, the second is 2, ...
359 * @return the column value; if the value is SQL <code>NULL</code>, the
360 * value returned is <code>null</code>
361 * @exception SQLException if a database access error occurs
362 */
363 public byte[] getBytes(int columnIndex) throws SQLException {
364 return resultSet.getBytes(columnIndex);
365 }
366
367 /***
368 * Retrieves the value of the designated column in the current row
369 * of this <code>ResultSet</code> object as
370 * a <code>java.sql.Date</code> object in the Java programming language.
371 *
372 * @param columnIndex the first column is 1, the second is 2, ...
373 * @return the column value; if the value is SQL <code>NULL</code>, the
374 * value returned is <code>null</code>
375 * @exception SQLException if a database access error occurs
376 */
377 public java.sql.Date getDate(int columnIndex) throws SQLException {
378 return resultSet.getDate(columnIndex);
379 }
380
381 /***
382 * Retrieves the value of the designated column in the current row
383 * of this <code>ResultSet</code> object as
384 * a <code>java.sql.Time</code> object in the Java programming language.
385 *
386 * @param columnIndex the first column is 1, the second is 2, ...
387 * @return the column value; if the value is SQL <code>NULL</code>, the
388 * value returned is <code>null</code>
389 * @exception SQLException if a database access error occurs
390 */
391 public java.sql.Time getTime(int columnIndex) throws SQLException {
392 return resultSet.getTime(columnIndex);
393 }
394
395 /***
396 * Retrieves the value of the designated column in the current row
397 * of this <code>ResultSet</code> object as
398 * a <code>java.sql.Timestamp</code> object in the Java programming language.
399 *
400 * @param columnIndex the first column is 1, the second is 2, ...
401 * @return the column value; if the value is SQL <code>NULL</code>, the
402 * value returned is <code>null</code>
403 * @exception SQLException if a database access error occurs
404 */
405 public java.sql.Timestamp getTimestamp(int columnIndex) throws SQLException {
406 return resultSet.getTimestamp(columnIndex);
407 }
408
409 /***
410 * Retrieves the value of the designated column in the current row
411 * of this <code>ResultSet</code> object as
412 * a stream of ASCII characters. The value can then be read in chunks from the
413 * stream. This method is particularly
414 * suitable for retrieving large <char>LONGVARCHAR</char> values.
415 * The JDBC driver will
416 * do any necessary conversion from the database format into ASCII.
417 *
418 * <P><B>Note:</B> All the data in the returned stream must be
419 * read prior to getting the value of any other column. The next
420 * call to a getter method implicitly closes the stream. Also, a
421 * stream may return <code>0</code> when the method
422 * <code>InputStream.available</code>
423 * is called whether there is data available or not.
424 *
425 * @param columnIndex the first column is 1, the second is 2, ...
426 * @return a Java input stream that delivers the database column value
427 * as a stream of one-byte ASCII characters;
428 * if the value is SQL <code>NULL</code>, the
429 * value returned is <code>null</code>
430 * @exception SQLException if a database access error occurs
431 */
432 public java.io.InputStream getAsciiStream(int columnIndex) throws SQLException {
433 return resultSet.getAsciiStream(columnIndex);
434 }
435
436 /***
437 * Retrieves the value of the designated column in the current row
438 * of this <code>ResultSet</code> object as
439 * as a stream of two-byte Unicode characters. The first byte is
440 * the high byte; the second byte is the low byte.
441 *
442 * The value can then be read in chunks from the
443 * stream. This method is particularly
444 * suitable for retrieving large <code>LONGVARCHAR</code>values. The
445 * JDBC driver will do any necessary conversion from the database
446 * format into Unicode.
447 *
448 * <P><B>Note:</B> All the data in the returned stream must be
449 * read prior to getting the value of any other column. The next
450 * call to a getter method implicitly closes the stream.
451 * Also, a stream may return <code>0</code> when the method
452 * <code>InputStream.available</code>
453 * is called, whether there is data available or not.
454 *
455 * @param columnIndex the first column is 1, the second is 2, ...
456 * @return a Java input stream that delivers the database column value
457 * as a stream of two-byte Unicode characters;
458 * if the value is SQL <code>NULL</code>, the value returned is
459 * <code>null</code>
460 *
461 * @exception SQLException if a database access error occurs
462 * @deprecated use <code>getCharacterStream</code> in place of
463 * <code>getUnicodeStream</code>
464 */
465 public java.io.InputStream getUnicodeStream(int columnIndex) throws SQLException {
466 return resultSet.getUnicodeStream(columnIndex);
467 }
468
469 /***
470 * Retrieves the value of the designated column in the current row
471 * of this <code>ResultSet</code> object as a binary stream of
472 * uninterpreted bytes. The value can then be read in chunks from the
473 * stream. This method is particularly
474 * suitable for retrieving large <code>LONGVARBINARY</code> values.
475 *
476 * <P><B>Note:</B> All the data in the returned stream must be
477 * read prior to getting the value of any other column. The next
478 * call to a getter method implicitly closes the stream. Also, a
479 * stream may return <code>0</code> when the method
480 * <code>InputStream.available</code>
481 * is called whether there is data available or not.
482 *
483 * @param columnIndex the first column is 1, the second is 2, ...
484 * @return a Java input stream that delivers the database column value
485 * as a stream of uninterpreted bytes;
486 * if the value is SQL <code>NULL</code>, the value returned is
487 * <code>null</code>
488 * @exception SQLException if a database access error occurs
489 */
490 public java.io.InputStream getBinaryStream(int columnIndex)
491 throws SQLException {
492
493 return resultSet.getBinaryStream(columnIndex);
494 }
495
496
497
498
499
500
501 /***
502 * Retrieves the value of the designated column in the current row
503 * of this <code>ResultSet</code> object as
504 * a <code>String</code> in the Java programming language.
505 *
506 * @param columnName the SQL name of the column
507 * @return the column value; if the value is SQL <code>NULL</code>, the
508 * value returned is <code>null</code>
509 * @exception SQLException if a database access error occurs
510 */
511 public String getString(String columnName) throws SQLException {
512 return resultSet.getString(columnName);
513 }
514
515 /***
516 * Retrieves the value of the designated column in the current row
517 * of this <code>ResultSet</code> object as
518 * a <code>boolean</code> in the Java programming language.
519 *
520 * @param columnName the SQL name of the column
521 * @return the column value; if the value is SQL <code>NULL</code>, the
522 * value returned is <code>false</code>
523 * @exception SQLException if a database access error occurs
524 */
525 public boolean getBoolean(String columnName) throws SQLException {
526 return resultSet.getBoolean(columnName);
527 }
528
529 /***
530 * Retrieves the value of the designated column in the current row
531 * of this <code>ResultSet</code> object as
532 * a <code>byte</code> in the Java programming language.
533 *
534 * @param columnName the SQL name of the column
535 * @return the column value; if the value is SQL <code>NULL</code>, the
536 * value returned is <code>0</code>
537 * @exception SQLException if a database access error occurs
538 */
539 public byte getByte(String columnName) throws SQLException {
540 return resultSet.getByte(columnName);
541 }
542
543 /***
544 * Retrieves the value of the designated column in the current row
545 * of this <code>ResultSet</code> object as
546 * a <code>short</code> in the Java programming language.
547 *
548 * @param columnName the SQL name of the column
549 * @return the column value; if the value is SQL <code>NULL</code>, the
550 * value returned is <code>0</code>
551 * @exception SQLException if a database access error occurs
552 */
553 public short getShort(String columnName) throws SQLException {
554 return resultSet.getShort(columnName);
555 }
556
557 /***
558 * Retrieves the value of the designated column in the current row
559 * of this <code>ResultSet</code> object as
560 * an <code>int</code> in the Java programming language.
561 *
562 * @param columnName the SQL name of the column
563 * @return the column value; if the value is SQL <code>NULL</code>, the
564 * value returned is <code>0</code>
565 * @exception SQLException if a database access error occurs
566 */
567 public int getInt(String columnName) throws SQLException {
568 return resultSet.getInt(columnName);
569 }
570
571 /***
572 * Retrieves the value of the designated column in the current row
573 * of this <code>ResultSet</code> object as
574 * a <code>long</code> in the Java programming language.
575 *
576 * @param columnName the SQL name of the column
577 * @return the column value; if the value is SQL <code>NULL</code>, the
578 * value returned is <code>0</code>
579 * @exception SQLException if a database access error occurs
580 */
581 public long getLong(String columnName) throws SQLException {
582 return resultSet.getLong(columnName);
583 }
584
585 /***
586 * Retrieves the value of the designated column in the current row
587 * of this <code>ResultSet</code> object as
588 * a <code>float</code> in the Java programming language.
589 *
590 * @param columnName the SQL name of the column
591 * @return the column value; if the value is SQL <code>NULL</code>, the
592 * value returned is <code>0</code>
593 * @exception SQLException if a database access error occurs
594 */
595 public float getFloat(String columnName) throws SQLException {
596 return resultSet.getFloat(columnName);
597 }
598
599 /***
600 * Retrieves the value of the designated column in the current row
601 * of this <code>ResultSet</code> object as
602 * a <code>double</code> in the Java programming language.
603 *
604 * @param columnName the SQL name of the column
605 * @return the column value; if the value is SQL <code>NULL</code>, the
606 * value returned is <code>0</code>
607 * @exception SQLException if a database access error occurs
608 */
609 public double getDouble(String columnName) throws SQLException {
610 return resultSet.getDouble(columnName);
611 }
612
613 /***
614 * Retrieves the value of the designated column in the current row
615 * of this <code>ResultSet</code> object as
616 * a <code>java.math.BigDecimal</code> in the Java programming language.
617 *
618 * @param columnName the SQL name of the column
619 * @param scale the number of digits to the right of the decimal point
620 * @return the column value; if the value is SQL <code>NULL</code>, the
621 * value returned is <code>null</code>
622 * @exception SQLException if a database access error occurs
623 * @deprecated
624 */
625 public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException {
626 return resultSet.getBigDecimal(columnName, scale);
627 }
628
629 /***
630 * Retrieves the value of the designated column in the current row
631 * of this <code>ResultSet</code> object as
632 * a <code>byte</code> array in the Java programming language.
633 * The bytes represent the raw values returned by the driver.
634 *
635 * @param columnName the SQL name of the column
636 * @return the column value; if the value is SQL <code>NULL</code>, the
637 * value returned is <code>null</code>
638 * @exception SQLException if a database access error occurs
639 */
640 public byte[] getBytes(String columnName) throws SQLException {
641 return resultSet.getBytes(columnName);
642 }
643
644 /***
645 * Retrieves the value of the designated column in the current row
646 * of this <code>ResultSet</code> object as
647 * a <code>java.sql.Date</code> object in the Java programming language.
648 *
649 * @param columnName the SQL name of the column
650 * @return the column value; if the value is SQL <code>NULL</code>, the
651 * value returned is <code>null</code>
652 * @exception SQLException if a database access error occurs
653 */
654 public java.sql.Date getDate(String columnName) throws SQLException {
655 return resultSet.getDate(columnName);
656 }
657
658 /***
659 * Retrieves the value of the designated column in the current row
660 * of this <code>ResultSet</code> object as
661 * a <code>java.sql.Time</code> object in the Java programming language.
662 *
663 * @param columnName the SQL name of the column
664 * @return the column value;
665 * if the value is SQL <code>NULL</code>,
666 * the value returned is <code>null</code>
667 * @exception SQLException if a database access error occurs
668 */
669 public java.sql.Time getTime(String columnName) throws SQLException {
670 return resultSet.getTime(columnName);
671 }
672
673 /***
674 * Retrieves the value of the designated column in the current row
675 * of this <code>ResultSet</code> object as
676 * a <code>java.sql.Timestamp</code> object.
677 *
678 * @param columnName the SQL name of the column
679 * @return the column value; if the value is SQL <code>NULL</code>, the
680 * value returned is <code>null</code>
681 * @exception SQLException if a database access error occurs
682 */
683 public java.sql.Timestamp getTimestamp(String columnName) throws SQLException {
684 return resultSet.getTimestamp(columnName);
685 }
686
687 /***
688 * Retrieves the value of the designated column in the current row
689 * of this <code>ResultSet</code> object as a stream of
690 * ASCII characters. The value can then be read in chunks from the
691 * stream. This method is particularly
692 * suitable for retrieving large <code>LONGVARCHAR</code> values.
693 * The JDBC driver will
694 * do any necessary conversion from the database format into ASCII.
695 *
696 * <P><B>Note:</B> All the data in the returned stream must be
697 * read prior to getting the value of any other column. The next
698 * call to a getter method implicitly closes the stream. Also, a
699 * stream may return <code>0</code> when the method <code>available</code>
700 * is called whether there is data available or not.
701 *
702 * @param columnName the SQL name of the column
703 * @return a Java input stream that delivers the database column value
704 * as a stream of one-byte ASCII characters.
705 * If the value is SQL <code>NULL</code>,
706 * the value returned is <code>null</code>.
707 * @exception SQLException if a database access error occurs
708 */
709 public java.io.InputStream getAsciiStream(String columnName) throws SQLException {
710 return resultSet.getAsciiStream(columnName);
711 }
712
713 /***
714 * Retrieves the value of the designated column in the current row
715 * of this <code>ResultSet</code> object as a stream of two-byte
716 * Unicode characters. The first byte is the high byte; the second
717 * byte is the low byte.
718 *
719 * The value can then be read in chunks from the
720 * stream. This method is particularly
721 * suitable for retrieving large <code>LONGVARCHAR</code> values.
722 * The JDBC technology-enabled driver will
723 * do any necessary conversion from the database format into Unicode.
724 *
725 * <P><B>Note:</B> All the data in the returned stream must be
726 * read prior to getting the value of any other column. The next
727 * call to a getter method implicitly closes the stream.
728 * Also, a stream may return <code>0</code> when the method
729 * <code>InputStream.available</code> is called, whether there
730 * is data available or not.
731 *
732 * @param columnName the SQL name of the column
733 * @return a Java input stream that delivers the database column value
734 * as a stream of two-byte Unicode characters.
735 * If the value is SQL <code>NULL</code>, the value returned
736 * is <code>null</code>.
737 * @exception SQLException if a database access error occurs
738 * @deprecated use <code>getCharacterStream</code> instead
739 */
740 public java.io.InputStream getUnicodeStream(String columnName) throws SQLException {
741 return resultSet.getUnicodeStream(columnName);
742 }
743
744 /***
745 * Retrieves the value of the designated column in the current row
746 * of this <code>ResultSet</code> object as a stream of uninterpreted
747 * <code>byte</code>s.
748 * The value can then be read in chunks from the
749 * stream. This method is particularly
750 * suitable for retrieving large <code>LONGVARBINARY</code>
751 * values.
752 *
753 * <P><B>Note:</B> All the data in the returned stream must be
754 * read prior to getting the value of any other column. The next
755 * call to a getter method implicitly closes the stream. Also, a
756 * stream may return <code>0</code> when the method <code>available</code>
757 * is called whether there is data available or not.
758 *
759 * @param columnName the SQL name of the column
760 * @return a Java input stream that delivers the database column value
761 * as a stream of uninterpreted bytes;
762 * if the value is SQL <code>NULL</code>, the result is <code>null</code>
763 * @exception SQLException if a database access error occurs
764 */
765 public java.io.InputStream getBinaryStream(String columnName)
766 throws SQLException {
767
768 return resultSet.getBinaryStream(columnName);
769 }
770
771
772
773
774
775
776 /***
777 * Retrieves the first warning reported by calls on this
778 * <code>ResultSet</code> object.
779 * Subsequent warnings on this <code>ResultSet</code> object
780 * will be chained to the <code>SQLWarning</code> object that
781 * this method returns.
782 *
783 * <P>The warning chain is automatically cleared each time a new
784 * row is read. This method may not be called on a <code>ResultSet</code>
785 * object that has been closed; doing so will cause an
786 * <code>SQLException</code> to be thrown.
787 * <P>
788 * <B>Note:</B> This warning chain only covers warnings caused
789 * by <code>ResultSet</code> methods. Any warning caused by
790 * <code>Statement</code> methods
791 * (such as reading OUT parameters) will be chained on the
792 * <code>Statement</code> object.
793 *
794 * @return the first <code>SQLWarning</code> object reported or
795 * <code>null</code> if there are none
796 * @exception SQLException if a database access error occurs or this method is
797 * called on a closed result set
798 */
799 public SQLWarning getWarnings() throws SQLException {
800 return resultSet.getWarnings();
801 }
802
803 /***
804 * Clears all warnings reported on this <code>ResultSet</code> object.
805 * After this method is called, the method <code>getWarnings</code>
806 * returns <code>null</code> until a new warning is
807 * reported for this <code>ResultSet</code> object.
808 *
809 * @exception SQLException if a database access error occurs
810 */
811 public void clearWarnings() throws SQLException {
812 resultSet.clearWarnings();
813 }
814
815 /***
816 * Retrieves the name of the SQL cursor used by this <code>ResultSet</code>
817 * object.
818 *
819 * <P>In SQL, a result table is retrieved through a cursor that is
820 * named. The current row of a result set can be updated or deleted
821 * using a positioned update/delete statement that references the
822 * cursor name. To insure that the cursor has the proper isolation
823 * level to support update, the cursor's <code>SELECT</code> statement
824 * should be of the form <code>SELECT FOR UPDATE</code>. If
825 * <code>FOR UPDATE</code> is omitted, the positioned updates may fail.
826 *
827 * <P>The JDBC API supports this SQL feature by providing the name of the
828 * SQL cursor used by a <code>ResultSet</code> object.
829 * The current row of a <code>ResultSet</code> object
830 * is also the current row of this SQL cursor.
831 *
832 * <P><B>Note:</B> If positioned update is not supported, a
833 * <code>SQLException</code> is thrown.
834 *
835 * @return the SQL name for this <code>ResultSet</code> object's cursor
836 * @exception SQLException if a database access error occurs
837 */
838 public String getCursorName() throws SQLException {
839 return resultSet.getCursorName();
840 }
841
842 /***
843 * Retrieves the number, types and properties of
844 * this <code>ResultSet</code> object's columns.
845 *
846 * @return the description of this <code>ResultSet</code> object's columns
847 * @exception SQLException if a database access error occurs
848 */
849 public ResultSetMetaData getMetaData() throws SQLException {
850 return resultSet.getMetaData();
851 }
852
853 /***
854 * <p>Gets the value of the designated column in the current row
855 * of this <code>ResultSet</code> object as
856 * an <code>Object</code> in the Java programming language.
857 *
858 * <p>This method will return the value of the given column as a
859 * Java object. The type of the Java object will be the default
860 * Java object type corresponding to the column's SQL type,
861 * following the mapping for built-in types specified in the JDBC
862 * specification. If the value is an SQL <code>NULL</code>,
863 * the driver returns a Java <code>null</code>.
864 *
865 * <p>This method may also be used to read database-specific
866 * abstract data types.
867 *
868 * In the JDBC 2.0 API, the behavior of method
869 * <code>getObject</code> is extended to materialize
870 * data of SQL user-defined types. When a column contains
871 * a structured or distinct value, the behavior of this method is as
872 * if it were a call to: <code>getObject(columnIndex,
873 * this.getStatement().getConnection().getTypeMap())</code>.
874 *
875 * @param columnIndex the first column is 1, the second is 2, ...
876 * @return a <code>java.lang.Object</code> holding the column value
877 * @exception SQLException if a database access error occurs
878 */
879 public Object getObject(int columnIndex) throws SQLException {
880 return resultSet.getObject(columnIndex);
881 }
882
883 /***
884 * <p>Gets the value of the designated column in the current row
885 * of this <code>ResultSet</code> object as
886 * an <code>Object</code> in the Java programming language.
887 *
888 * <p>This method will return the value of the given column as a
889 * Java object. The type of the Java object will be the default
890 * Java object type corresponding to the column's SQL type,
891 * following the mapping for built-in types specified in the JDBC
892 * specification. If the value is an SQL <code>NULL</code>,
893 * the driver returns a Java <code>null</code>.
894 * <P>
895 * This method may also be used to read database-specific
896 * abstract data types.
897 * <P>
898 * In the JDBC 2.0 API, the behavior of the method
899 * <code>getObject</code> is extended to materialize
900 * data of SQL user-defined types. When a column contains
901 * a structured or distinct value, the behavior of this method is as
902 * if it were a call to: <code>getObject(columnIndex,
903 * this.getStatement().getConnection().getTypeMap())</code>.
904 *
905 * @param columnName the SQL name of the column
906 * @return a <code>java.lang.Object</code> holding the column value
907 * @exception SQLException if a database access error occurs
908 */
909 public Object getObject(String columnName) throws SQLException {
910 return resultSet.getObject(columnName);
911 }
912
913
914
915 /***
916 * Maps the given <code>ResultSet</code> column name to its
917 * <code>ResultSet</code> column index.
918 *
919 * @param columnName the name of the column
920 * @return the column index of the given column name
921 * @exception SQLException if the <code>ResultSet</code> object
922 * does not contain <code>columnName</code> or a database access error occurs
923 */
924 public int findColumn(String columnName) throws SQLException {
925 return resultSet.findColumn(columnName);
926 }
927
928
929
930
931
932
933
934
935 /***
936 * Retrieves the value of the designated column in the current row
937 * of this <code>ResultSet</code> object as a
938 * <code>java.io.Reader</code> object.
939 * @return a <code>java.io.Reader</code> object that contains the column
940 * value; if the value is SQL <code>NULL</code>, the value returned is
941 * <code>null</code> in the Java programming language.
942 * @param columnIndex the first column is 1, the second is 2, ...
943 * @exception SQLException if a database access error occurs
944 * @since 1.2
945 */
946 public java.io.Reader getCharacterStream(int columnIndex) throws SQLException {
947 return resultSet.getCharacterStream(columnIndex);
948 }
949
950 /***
951 * Retrieves the value of the designated column in the current row
952 * of this <code>ResultSet</code> object as a
953 * <code>java.io.Reader</code> object.
954 *
955 * @param columnName the name of the column
956 * @return a <code>java.io.Reader</code> object that contains the column
957 * value; if the value is SQL <code>NULL</code>, the value returned is
958 * <code>null</code> in the Java programming language
959 * @exception SQLException if a database access error occurs
960 * @since 1.2
961 */
962 public java.io.Reader getCharacterStream(String columnName) throws SQLException {
963 return resultSet.getCharacterStream(columnName);
964 }
965
966 /***
967 * Retrieves the value of the designated column in the current row
968 * of this <code>ResultSet</code> object as a
969 * <code>java.math.BigDecimal</code> with full precision.
970 *
971 * @param columnIndex the first column is 1, the second is 2, ...
972 * @return the column value (full precision);
973 * if the value is SQL <code>NULL</code>, the value returned is
974 * <code>null</code> in the Java programming language.
975 * @exception SQLException if a database access error occurs
976 * @since 1.2
977 */
978 public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
979 return resultSet.getBigDecimal(columnIndex);
980 }
981
982 /***
983 * Retrieves the value of the designated column in the current row
984 * of this <code>ResultSet</code> object as a
985 * <code>java.math.BigDecimal</code> with full precision.
986 *
987 * @param columnName the column name
988 * @return the column value (full precision);
989 * if the value is SQL <code>NULL</code>, the value returned is
990 * <code>null</code> in the Java programming language.
991 * @exception SQLException if a database access error occurs
992 * @since 1.2
993 *
994 */
995 public BigDecimal getBigDecimal(String columnName) throws SQLException {
996 return resultSet.getBigDecimal(columnName);
997 }
998
999
1000
1001
1002
1003 /***
1004 * Retrieves whether the cursor is before the first row in
1005 * this <code>ResultSet</code> object.
1006 *
1007 * @return <code>true</code> if the cursor is before the first row;
1008 * <code>false</code> if the cursor is at any other position or the
1009 * result set contains no rows
1010 * @exception SQLException if a database access error occurs
1011 * @since 1.2
1012 */
1013 public boolean isBeforeFirst() throws SQLException {
1014 return resultSet.isBeforeFirst();
1015 }
1016
1017 /***
1018 * Retrieves whether the cursor is after the last row in
1019 * this <code>ResultSet</code> object.
1020 *
1021 * @return <code>true</code> if the cursor is after the last row;
1022 * <code>false</code> if the cursor is at any other position or the
1023 * result set contains no rows
1024 * @exception SQLException if a database access error occurs
1025 * @since 1.2
1026 */
1027 public boolean isAfterLast() throws SQLException {
1028 return resultSet.isAfterLast();
1029 }
1030
1031 /***
1032 * Retrieves whether the cursor is on the first row of
1033 * this <code>ResultSet</code> object.
1034 *
1035 * @return <code>true</code> if the cursor is on the first row;
1036 * <code>false</code> otherwise
1037 * @exception SQLException if a database access error occurs
1038 * @since 1.2
1039 */
1040 public boolean isFirst() throws SQLException {
1041 return resultSet.isFirst();
1042 }
1043
1044 /***
1045 * Retrieves whether the cursor is on the last row of
1046 * this <code>ResultSet</code> object.
1047 * Note: Calling the method <code>isLast</code> may be expensive
1048 * because the JDBC driver
1049 * might need to fetch ahead one row in order to determine
1050 * whether the current row is the last row in the result set.
1051 *
1052 * @return <code>true</code> if the cursor is on the last row;
1053 * <code>false</code> otherwise
1054 * @exception SQLException if a database access error occurs
1055 * @since 1.2
1056 */
1057 public boolean isLast() throws SQLException {
1058 return resultSet.isLast();
1059 }
1060
1061 /***
1062 * Moves the cursor to the front of
1063 * this <code>ResultSet</code> object, just before the
1064 * first row. This method has no effect if the result set contains no rows.
1065 *
1066 * @exception SQLException if a database access error
1067 * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
1068 * @since 1.2
1069 */
1070 public void beforeFirst() throws SQLException {
1071 resultSet.beforeFirst();
1072 }
1073
1074 /***
1075 * Moves the cursor to the end of
1076 * this <code>ResultSet</code> object, just after the
1077 * last row. This method has no effect if the result set contains no rows.
1078 * @exception SQLException if a database access error
1079 * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
1080 * @since 1.2
1081 */
1082 public void afterLast() throws SQLException {
1083 resultSet.afterLast();
1084 }
1085
1086 /***
1087 * Moves the cursor to the first row in
1088 * this <code>ResultSet</code> object.
1089 *
1090 * @return <code>true</code> if the cursor is on a valid row;
1091 * <code>false</code> if there are no rows in the result set
1092 * @exception SQLException if a database access error
1093 * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
1094 * @since 1.2
1095 */
1096 public boolean first() throws SQLException {
1097 return resultSet.first();
1098 }
1099
1100 /***
1101 * Moves the cursor to the last row in
1102 * this <code>ResultSet</code> object.
1103 *
1104 * @return <code>true</code> if the cursor is on a valid row;
1105 * <code>false</code> if there are no rows in the result set
1106 * @exception SQLException if a database access error
1107 * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
1108 * @since 1.2
1109 */
1110 public boolean last() throws SQLException {
1111 return resultSet.last();
1112 }
1113
1114 /***
1115 * Retrieves the current row number. The first row is number 1, the
1116 * second number 2, and so on.
1117 *
1118 * @return the current row number; <code>0</code> if there is no current row
1119 * @exception SQLException if a database access error occurs
1120 * @since 1.2
1121 */
1122 public int getRow() throws SQLException {
1123 return resultSet.getRow();
1124 }
1125
1126 /***
1127 * Moves the cursor to the given row number in
1128 * this <code>ResultSet</code> object.
1129 *
1130 * <p>If the row number is positive, the cursor moves to
1131 * the given row number with respect to the
1132 * beginning of the result set. The first row is row 1, the second
1133 * is row 2, and so on.
1134 *
1135 * <p>If the given row number is negative, the cursor moves to
1136 * an absolute row position with respect to
1137 * the end of the result set. For example, calling the method
1138 * <code>absolute(-1)</code> positions the
1139 * cursor on the last row; calling the method <code>absolute(-2)</code>
1140 * moves the cursor to the next-to-last row, and so on.
1141 *
1142 * <p>An attempt to position the cursor beyond the first/last row in
1143 * the result set leaves the cursor before the first row or after
1144 * the last row.
1145 *
1146 * <p><B>Note:</B> Calling <code>absolute(1)</code> is the same
1147 * as calling <code>first()</code>. Calling <code>absolute(-1)</code>
1148 * is the same as calling <code>last()</code>.
1149 *
1150 * @param row the number of the row to which the cursor should move.
1151 * A positive number indicates the row number counting from the
1152 * beginning of the result set; a negative number indicates the
1153 * row number counting from the end of the result set
1154 * @return <code>true</code> if the cursor is on the result set;
1155 * <code>false</code> otherwise
1156 * @exception SQLException if a database access error
1157 * occurs, or the result set type is <code>TYPE_FORWARD_ONLY</code>
1158 * @since 1.2
1159 */
1160 public boolean absolute( int row ) throws SQLException {
1161 return resultSet.absolute(row);
1162 }
1163
1164 /***
1165 * Moves the cursor a relative number of rows, either positive or negative.
1166 * Attempting to move beyond the first/last row in the
1167 * result set positions the cursor before/after the
1168 * the first/last row. Calling <code>relative(0)</code> is valid, but does
1169 * not change the cursor position.
1170 *
1171 * <p>Note: Calling the method <code>relative(1)</code>
1172 * is identical to calling the method <code>next()</code> and
1173 * calling the method <code>relative(-1)</code> is identical
1174 * to calling the method <code>previous()</code>.
1175 *
1176 * @param rows an <code>int</code> specifying the number of rows to
1177 * move from the current row; a positive number moves the cursor
1178 * forward; a negative number moves the cursor backward
1179 * @return <code>true</code> if the cursor is on a row;
1180 * <code>false</code> otherwise
1181 * @exception SQLException if a database access error occurs,
1182 * there is no current row, or the result set type is
1183 * <code>TYPE_FORWARD_ONLY</code>
1184 * @since 1.2
1185 */
1186 public boolean relative( int rows ) throws SQLException {
1187 return resultSet.relative(rows);
1188 }
1189
1190 /***
1191 * Moves the cursor to the previous row in this
1192 * <code>ResultSet</code> object.
1193 *
1194 * @return <code>true</code> if the cursor is on a valid row;
1195 * <code>false</code> if it is off the result set
1196 * @exception SQLException if a database access error
1197 * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
1198 * @since 1.2
1199 */
1200 public boolean previous() throws SQLException {
1201 if (updated) {
1202 resultSet.updateRow();
1203 updated = false;
1204 }
1205 return resultSet.previous();
1206 }
1207
1208 /***
1209 * Gives a hint as to the direction in which the rows in this
1210 * <code>ResultSet</code> object will be processed.
1211 * The initial value is determined by the
1212 * <code>Statement</code> object
1213 * that produced this <code>ResultSet</code> object.
1214 * The fetch direction may be changed at any time.
1215 *
1216 * @param direction an <code>int</code> specifying the suggested
1217 * fetch direction; one of <code>ResultSet.FETCH_FORWARD</code>,
1218 * <code>ResultSet.FETCH_REVERSE</code>, or
1219 * <code>ResultSet.FETCH_UNKNOWN</code>
1220 * @exception SQLException if a database access error occurs or
1221 * the result set type is <code>TYPE_FORWARD_ONLY</code> and the fetch
1222 * direction is not <code>FETCH_FORWARD</code>
1223 * @since 1.2
1224 * @see Statement#setFetchDirection
1225 * @see #getFetchDirection
1226 */
1227 public void setFetchDirection(int direction) throws SQLException {
1228 resultSet.setFetchDirection(direction);
1229 }
1230
1231 /***
1232 * Retrieves the fetch direction for this
1233 * <code>ResultSet</code> object.
1234 *
1235 * @return the current fetch direction for this <code>ResultSet</code> object
1236 * @exception SQLException if a database access error occurs
1237 * @since 1.2
1238 * @see #setFetchDirection
1239 */
1240 public int getFetchDirection() throws SQLException {
1241 return resultSet.getFetchDirection();
1242 }
1243
1244 /***
1245 * Gives the JDBC driver a hint as to the number of rows that should
1246 * be fetched from the database when more rows are needed for this
1247 * <code>ResultSet</code> object.
1248 * If the fetch size specified is zero, the JDBC driver
1249 * ignores the value and is free to make its own best guess as to what
1250 * the fetch size should be. The default value is set by the
1251 * <code>Statement</code> object
1252 * that created the result set. The fetch size may be changed at any time.
1253 *
1254 * @param rows the number of rows to fetch
1255 * @exception SQLException if a database access error occurs or the
1256 * condition <code>0 <= rows <= Statement.getMaxRows()</code> is not satisfied
1257 * @since 1.2
1258 * @see #getFetchSize
1259 */
1260 public void setFetchSize(int rows) throws SQLException {
1261 resultSet.setFetchSize(rows);
1262 }
1263
1264 /***
1265 * Retrieves the fetch size for this
1266 * <code>ResultSet</code> object.
1267 *
1268 * @return the current fetch size for this <code>ResultSet</code> object
1269 * @exception SQLException if a database access error occurs
1270 * @since 1.2
1271 * @see #setFetchSize
1272 */
1273 public int getFetchSize() throws SQLException {
1274 return resultSet.getFetchSize();
1275 }
1276
1277 /***
1278 * Retrieves the type of this <code>ResultSet</code> object.
1279 * The type is determined by the <code>Statement</code> object
1280 * that created the result set.
1281 *
1282 * @return <code>ResultSet.TYPE_FORWARD_ONLY</code>,
1283 * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>,
1284 * or <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
1285 * @exception SQLException if a database access error occurs
1286 * @since 1.2
1287 */
1288 public int getType() throws SQLException {
1289 return resultSet.getType();
1290 }
1291
1292 /***
1293 * Retrieves the concurrency mode of this <code>ResultSet</code> object.
1294 * The concurrency used is determined by the
1295 * <code>Statement</code> object that created the result set.
1296 *
1297 * @return the concurrency type, either
1298 * <code>ResultSet.CONCUR_READ_ONLY</code>
1299 * or <code>ResultSet.CONCUR_UPDATABLE</code>
1300 * @exception SQLException if a database access error occurs
1301 * @since 1.2
1302 */
1303 public int getConcurrency() throws SQLException {
1304 return resultSet.getConcurrency();
1305 }
1306
1307
1308
1309
1310
1311 /***
1312 * Retrieves whether the current row has been updated. The value returned
1313 * depends on whether or not the result set can detect updates.
1314 *
1315 * @return <code>true</code> if both (1) the row has been visibly updated
1316 * by the owner or another and (2) updates are detected
1317 * @exception SQLException if a database access error occurs
1318 * @see DatabaseMetaData#updatesAreDetected
1319 * @since 1.2
1320 */
1321 public boolean rowUpdated() throws SQLException {
1322 return resultSet.rowUpdated();
1323 }
1324
1325 /***
1326 * Retrieves whether the current row has had an insertion.
1327 * The value returned depends on whether or not this
1328 * <code>ResultSet</code> object can detect visible inserts.
1329 *
1330 * @return <code>true</code> if a row has had an insertion
1331 * and insertions are detected; <code>false</code> otherwise
1332 * @exception SQLException if a database access error occurs
1333 *
1334 * @see DatabaseMetaData#insertsAreDetected
1335 * @since 1.2
1336 */
1337 public boolean rowInserted() throws SQLException {
1338 return resultSet.rowInserted();
1339 }
1340
1341 /***
1342 * Retrieves whether a row has been deleted. A deleted row may leave
1343 * a visible "hole" in a result set. This method can be used to
1344 * detect holes in a result set. The value returned depends on whether
1345 * or not this <code>ResultSet</code> object can detect deletions.
1346 *
1347 * @return <code>true</code> if a row was deleted and deletions are detected;
1348 * <code>false</code> otherwise
1349 * @exception SQLException if a database access error occurs
1350 *
1351 * @see DatabaseMetaData#deletesAreDetected
1352 * @since 1.2
1353 */
1354 public boolean rowDeleted() throws SQLException {
1355 return resultSet.rowDeleted();
1356 }
1357
1358 /***
1359 * Gives a nullable column a null value.
1360 *
1361 * The updater methods are used to update column values in the
1362 * current row or the insert row. The updater methods do not
1363 * update the underlying database; instead the <code>updateRow</code>
1364 * or <code>insertRow</code> methods are called to update the database.
1365 *
1366 * @param columnIndex the first column is 1, the second is 2, ...
1367 * @exception SQLException if a database access error occurs
1368 * @since 1.2
1369 */
1370 public void updateNull(int columnIndex) throws SQLException {
1371 resultSet.updateNull(columnIndex);
1372 }
1373
1374 /***
1375 * Updates the designated column with a <code>boolean</code> value.
1376 * The updater methods are used to update column values in the
1377 * current row or the insert row. The updater methods do not
1378 * update the underlying database; instead the <code>updateRow</code> or
1379 * <code>insertRow</code> methods are called to update the database.
1380 *
1381 * @param columnIndex the first column is 1, the second is 2, ...
1382 * @param x the new column value
1383 * @exception SQLException if a database access error occurs
1384 * @since 1.2
1385 */
1386 public void updateBoolean(int columnIndex, boolean x) throws SQLException {
1387 resultSet.updateBoolean(columnIndex, x);
1388 }
1389
1390 /***
1391 * Updates the designated column with a <code>byte</code> value.
1392 * The updater methods are used to update column values in the
1393 * current row or the insert row. The updater methods do not
1394 * update the underlying database; instead the <code>updateRow</code> or
1395 * <code>insertRow</code> methods are called to update the database.
1396 *
1397 *
1398 * @param columnIndex the first column is 1, the second is 2, ...
1399 * @param x the new column value
1400 * @exception SQLException if a database access error occurs
1401 * @since 1.2
1402 */
1403 public void updateByte(int columnIndex, byte x) throws SQLException {
1404 resultSet.updateByte(columnIndex, x);
1405 }
1406
1407 /***
1408 * Updates the designated column with a <code>short</code> value.
1409 * The updater methods are used to update column values in the
1410 * current row or the insert row. The updater methods do not
1411 * update the underlying database; instead the <code>updateRow</code> or
1412 * <code>insertRow</code> methods are called to update the database.
1413 *
1414 * @param columnIndex the first column is 1, the second is 2, ...
1415 * @param x the new column value
1416 * @exception SQLException if a database access error occurs
1417 * @since 1.2
1418 */
1419 public void updateShort(int columnIndex, short x) throws SQLException {
1420 resultSet.updateShort(columnIndex, x);
1421 }
1422
1423 /***
1424 * Updates the designated column with an <code>int</code> value.
1425 * The updater methods are used to update column values in the
1426 * current row or the insert row. The updater methods do not
1427 * update the underlying database; instead the <code>updateRow</code> or
1428 * <code>insertRow</code> methods are called to update the database.
1429 *
1430 * @param columnIndex the first column is 1, the second is 2, ...
1431 * @param x the new column value
1432 * @exception SQLException if a database access error occurs
1433 * @since 1.2
1434 */
1435 public void updateInt(int columnIndex, int x) throws SQLException {
1436 resultSet.updateInt(columnIndex, x);
1437 }
1438
1439 /***
1440 * Updates the designated column with a <code>long</code> value.
1441 * The updater methods are used to update column values in the
1442 * current row or the insert row. The updater methods do not
1443 * update the underlying database; instead the <code>updateRow</code> or
1444 * <code>insertRow</code> methods are called to update the database.
1445 *
1446 * @param columnIndex the first column is 1, the second is 2, ...
1447 * @param x the new column value
1448 * @exception SQLException if a database access error occurs
1449 * @since 1.2
1450 */
1451 public void updateLong(int columnIndex, long x) throws SQLException {
1452 resultSet.updateLong(columnIndex, x);
1453 }
1454
1455 /***
1456 * Updates the designated column with a <code>float</code> value.
1457 * The updater methods are used to update column values in the
1458 * current row or the insert row. The updater methods do not
1459 * update the underlying database; instead the <code>updateRow</code> or
1460 * <code>insertRow</code> methods are called to update the database.
1461 *
1462 * @param columnIndex the first column is 1, the second is 2, ...
1463 * @param x the new column value
1464 * @exception SQLException if a database access error occurs
1465 * @since 1.2
1466 */
1467 public void updateFloat(int columnIndex, float x) throws SQLException {
1468 resultSet.updateFloat(columnIndex, x);
1469 }
1470
1471 /***
1472 * Updates the designated column with a <code>double</code> value.
1473 * The updater methods are used to update column values in the
1474 * current row or the insert row. The updater methods do not
1475 * update the underlying database; instead the <code>updateRow</code> or
1476 * <code>insertRow</code> methods are called to update the database.
1477 *
1478 * @param columnIndex the first column is 1, the second is 2, ...
1479 * @param x the new column value
1480 * @exception SQLException if a database access error occurs
1481 * @since 1.2
1482 */
1483 public void updateDouble(int columnIndex, double x) throws SQLException {
1484 resultSet.updateDouble(columnIndex, x);
1485 }
1486
1487 /***
1488 * Updates the designated column with a <code>java.math.BigDecimal</code>
1489 * value.
1490 * The updater methods are used to update column values in the
1491 * current row or the insert row. The updater methods do not
1492 * update the underlying database; instead the <code>updateRow</code> or
1493 * <code>insertRow</code> methods are called to update the database.
1494 *
1495 * @param columnIndex the first column is 1, the second is 2, ...
1496 * @param x the new column value
1497 * @exception SQLException if a database access error occurs
1498 * @since 1.2
1499 */
1500 public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException {
1501 resultSet.updateBigDecimal(columnIndex, x);
1502 }
1503
1504 /***
1505 * Updates the designated column with a <code>String</code> value.
1506 * The updater methods are used to update column values in the
1507 * current row or the insert row. The updater methods do not
1508 * update the underlying database; instead the <code>updateRow</code> or
1509 * <code>insertRow</code> methods are called to update the database.
1510 *
1511 * @param columnIndex the first column is 1, the second is 2, ...
1512 * @param x the new column value
1513 * @exception SQLException if a database access error occurs
1514 * @since 1.2
1515 */
1516 public void updateString(int columnIndex, String x) throws SQLException {
1517 resultSet.updateString(columnIndex, x);
1518 }
1519
1520 /***
1521 * Updates the designated column with a <code>byte</code> array value.
1522 * The updater methods are used to update column values in the
1523 * current row or the insert row. The updater methods do not
1524 * update the underlying database; instead the <code>updateRow</code> or
1525 * <code>insertRow</code> methods are called to update the database.
1526 *
1527 * @param columnIndex the first column is 1, the second is 2, ...
1528 * @param x the new column value
1529 * @exception SQLException if a database access error occurs
1530 * @since 1.2
1531 */
1532 public void updateBytes(int columnIndex, byte x[]) throws SQLException {
1533 resultSet.updateBytes(columnIndex, x);
1534 }
1535
1536 /***
1537 * Updates the designated column with a <code>java.sql.Date</code> value.
1538 * The updater methods are used to update column values in the
1539 * current row or the insert row. The updater methods do not
1540 * update the underlying database; instead the <code>updateRow</code> or
1541 * <code>insertRow</code> methods are called to update the database.
1542 *
1543 * @param columnIndex the first column is 1, the second is 2, ...
1544 * @param x the new column value
1545 * @exception SQLException if a database access error occurs
1546 * @since 1.2
1547 */
1548 public void updateDate(int columnIndex, java.sql.Date x) throws SQLException {
1549 resultSet.updateDate(columnIndex, x);
1550 }
1551
1552 /***
1553 * Updates the designated column with a <code>java.sql.Time</code> value.
1554 * The updater methods are used to update column values in the
1555 * current row or the insert row. The updater methods do not
1556 * update the underlying database; instead the <code>updateRow</code> or
1557 * <code>insertRow</code> methods are called to update the database.
1558 *
1559 * @param columnIndex the first column is 1, the second is 2, ...
1560 * @param x the new column value
1561 * @exception SQLException if a database access error occurs
1562 * @since 1.2
1563 */
1564 public void updateTime(int columnIndex, java.sql.Time x) throws SQLException {
1565 resultSet.updateTime(columnIndex, x);
1566 }
1567
1568 /***
1569 * Updates the designated column with a <code>java.sql.Timestamp</code>
1570 * value.
1571 * The updater methods are used to update column values in the
1572 * current row or the insert row. The updater methods do not
1573 * update the underlying database; instead the <code>updateRow</code> or
1574 * <code>insertRow</code> methods are called to update the database.
1575 *
1576 * @param columnIndex the first column is 1, the second is 2, ...
1577 * @param x the new column value
1578 * @exception SQLException if a database access error occurs
1579 * @since 1.2
1580 */
1581 public void updateTimestamp(int columnIndex, java.sql.Timestamp x)
1582 throws SQLException {
1583 resultSet.updateTimestamp(columnIndex, x);
1584 }
1585
1586 /***
1587 * Updates the designated column with an ascii stream value.
1588 * The updater methods are used to update column values in the
1589 * current row or the insert row. The updater methods do not
1590 * update the underlying database; instead the <code>updateRow</code> or
1591 * <code>insertRow</code> methods are called to update the database.
1592 *
1593 * @param columnIndex the first column is 1, the second is 2, ...
1594 * @param x the new column value
1595 * @param length the length of the stream
1596 * @exception SQLException if a database access error occurs
1597 * @since 1.2
1598 */
1599 public void updateAsciiStream(int columnIndex,
1600 java.io.InputStream x,
1601 int length) throws SQLException {
1602 resultSet.updateAsciiStream(columnIndex, x, length);
1603 }
1604
1605 /***
1606 * Updates the designated column with a binary stream value.
1607 * The updater methods are used to update column values in the
1608 * current row or the insert row. The updater methods do not
1609 * update the underlying database; instead the <code>updateRow</code> or
1610 * <code>insertRow</code> methods are called to update the database.
1611 *
1612 * @param columnIndex the first column is 1, the second is 2, ...
1613 * @param x the new column value
1614 * @param length the length of the stream
1615 * @exception SQLException if a database access error occurs
1616 * @since 1.2
1617 */
1618 public void updateBinaryStream(int columnIndex,
1619 java.io.InputStream x,
1620 int length) throws SQLException {
1621 resultSet.updateBinaryStream(columnIndex, x, length);
1622 }
1623
1624 /***
1625 * Updates the designated column with a character stream value.
1626 * The updater methods are used to update column values in the
1627 * current row or the insert row. The updater methods do not
1628 * update the underlying database; instead the <code>updateRow</code> or
1629 * <code>insertRow</code> methods are called to update the database.
1630 *
1631 * @param columnIndex the first column is 1, the second is 2, ...
1632 * @param x the new column value
1633 * @param length the length of the stream
1634 * @exception SQLException if a database access error occurs
1635 * @since 1.2
1636 */
1637 public void updateCharacterStream(int columnIndex,
1638 java.io.Reader x,
1639 int length) throws SQLException {
1640 resultSet.updateCharacterStream(columnIndex, x, length);
1641 }
1642
1643 /***
1644 * Updates the designated column with an <code>Object</code> value.
1645 * The updater methods are used to update column values in the
1646 * current row or the insert row. The updater methods do not
1647 * update the underlying database; instead the <code>updateRow</code> or
1648 * <code>insertRow</code> methods are called to update the database.
1649 *
1650 * @param columnIndex the first column is 1, the second is 2, ...
1651 * @param x the new column value
1652 * @param scale for <code>java.sql.Types.DECIMA</code>
1653 * or <code>java.sql.Types.NUMERIC</code> types,
1654 * this is the number of digits after the decimal point. For all other
1655 * types this value will be ignored.
1656 * @exception SQLException if a database access error occurs
1657 * @since 1.2
1658 */
1659 public void updateObject(int columnIndex, Object x, int scale)
1660 throws SQLException {
1661 resultSet.updateObject(columnIndex, x, scale);
1662 }
1663
1664 /***
1665 * Updates the designated column with an <code>Object</code> value.
1666 * The updater methods are used to update column values in the
1667 * current row or the insert row. The updater methods do not
1668 * update the underlying database; instead the <code>updateRow</code> or
1669 * <code>insertRow</code> methods are called to update the database.
1670 *
1671 * @param columnIndex the first column is 1, the second is 2, ...
1672 * @param x the new column value
1673 * @exception SQLException if a database access error occurs
1674 * @since 1.2
1675 */
1676 public void updateObject(int columnIndex, Object x) throws SQLException {
1677 resultSet.updateObject(columnIndex, x);
1678 }
1679
1680 /***
1681 * Updates the designated column with a <code>null</code> value.
1682 * The updater methods are used to update column values in the
1683 * current row or the insert row. The updater methods do not
1684 * update the underlying database; instead the <code>updateRow</code> or
1685 * <code>insertRow</code> methods are called to update the database.
1686 *
1687 * @param columnName the name of the column
1688 * @exception SQLException if a database access error occurs
1689 * @since 1.2
1690 */
1691 public void updateNull(String columnName) throws SQLException {
1692 resultSet.updateNull(columnName);
1693 }
1694
1695 /***
1696 * Updates the designated column with a <code>boolean</code> value.
1697 * The updater methods are used to update column values in the
1698 * current row or the insert row. The updater methods do not
1699 * update the underlying database; instead the <code>updateRow</code> or
1700 * <code>insertRow</code> methods are called to update the database.
1701 *
1702 * @param columnName the name of the column
1703 * @param x the new column value
1704 * @exception SQLException if a database access error occurs
1705 * @since 1.2
1706 */
1707 public void updateBoolean(String columnName, boolean x) throws SQLException {
1708 resultSet.updateBoolean(columnName, x);
1709 }
1710
1711 /***
1712 * Updates the designated column with a <code>byte</code> value.
1713 * The updater methods are used to update column values in the
1714 * current row or the insert row. The updater methods do not
1715 * update the underlying database; instead the <code>updateRow</code> or
1716 * <code>insertRow</code> methods are called to update the database.
1717 *
1718 * @param columnName the name of the column
1719 * @param x the new column value
1720 * @exception SQLException if a database access error occurs
1721 * @since 1.2
1722 */
1723 public void updateByte(String columnName, byte x) throws SQLException {
1724 resultSet.updateByte(columnName, x);
1725 }
1726
1727 /***
1728 * Updates the designated column with a <code>short</code> value.
1729 * The updater methods are used to update column values in the
1730 * current row or the insert row. The updater methods do not
1731 * update the underlying database; instead the <code>updateRow</code> or
1732 * <code>insertRow</code> methods are called to update the database.
1733 *
1734 * @param columnName the name of the column
1735 * @param x the new column value
1736 * @exception SQLException if a database access error occurs
1737 * @since 1.2
1738 */
1739 public void updateShort(String columnName, short x) throws SQLException {
1740 resultSet.updateShort(columnName, x);
1741 }
1742
1743 /***
1744 * Updates the designated column with an <code>int</code> value.
1745 * The updater methods are used to update column values in the
1746 * current row or the insert row. The updater methods do not
1747 * update the underlying database; instead the <code>updateRow</code> or
1748 * <code>insertRow</code> methods are called to update the database.
1749 *
1750 * @param columnName the name of the column
1751 * @param x the new column value
1752 * @exception SQLException if a database access error occurs
1753 * @since 1.2
1754 */
1755 public void updateInt(String columnName, int x) throws SQLException {
1756 resultSet.updateInt(columnName, x);
1757 }
1758
1759 /***
1760 * Updates the designated column with a <code>long</code> value.
1761 * The updater methods are used to update column values in the
1762 * current row or the insert row. The updater methods do not
1763 * update the underlying database; instead the <code>updateRow</code> or
1764 * <code>insertRow</code> methods are called to update the database.
1765 *
1766 * @param columnName the name of the column
1767 * @param x the new column value
1768 * @exception SQLException if a database access error occurs
1769 * @since 1.2
1770 */
1771 public void updateLong(String columnName, long x) throws SQLException {
1772 resultSet.updateLong(columnName, x);
1773 }
1774
1775 /***
1776 * Updates the designated column with a <code>float </code> value.
1777 * The updater methods are used to update column values in the
1778 * current row or the insert row. The updater methods do not
1779 * update the underlying database; instead the <code>updateRow</code> or
1780 * <code>insertRow</code> methods are called to update the database.
1781 *
1782 * @param columnName the name of the column
1783 * @param x the new column value
1784 * @exception SQLException if a database access error occurs
1785 * @since 1.2
1786 */
1787 public void updateFloat(String columnName, float x) throws SQLException {
1788 resultSet.updateFloat(columnName, x);
1789 }
1790
1791 /***
1792 * Updates the designated column with a <code>double</code> value.
1793 * The updater methods are used to update column values in the
1794 * current row or the insert row. The updater methods do not
1795 * update the underlying database; instead the <code>updateRow</code> or
1796 * <code>insertRow</code> methods are called to update the database.
1797 *
1798 * @param columnName the name of the column
1799 * @param x the new column value
1800 * @exception SQLException if a database access error occurs
1801 * @since 1.2
1802 */
1803 public void updateDouble(String columnName, double x) throws SQLException {
1804 resultSet.updateDouble(columnName, x);
1805 }
1806
1807 /***
1808 * Updates the designated column with a <code>java.sql.BigDecimal</code>
1809 * value.
1810 * The updater methods are used to update column values in the
1811 * current row or the insert row. The updater methods do not
1812 * update the underlying database; instead the <code>updateRow</code> or
1813 * <code>insertRow</code> methods are called to update the database.
1814 *
1815 * @param columnName the name of the column
1816 * @param x the new column value
1817 * @exception SQLException if a database access error occurs
1818 * @since 1.2
1819 */
1820 public void updateBigDecimal(String columnName, BigDecimal x) throws SQLException {
1821 resultSet.updateBigDecimal(columnName, x);
1822 }
1823
1824 /***
1825 * Updates the designated column with a <code>String</code> value.
1826 * The updater methods are used to update column values in the
1827 * current row or the insert row. The updater methods do not
1828 * update the underlying database; instead the <code>updateRow</code> or
1829 * <code>insertRow</code> methods are called to update the database.
1830 *
1831 * @param columnName the name of the column
1832 * @param x the new column value
1833 * @exception SQLException if a database access error occurs
1834 * @since 1.2
1835 */
1836 public void updateString(String columnName, String x) throws SQLException {
1837 resultSet.updateString(columnName, x);
1838 }
1839
1840 /***
1841 * Updates the designated column with a byte array value.
1842 *
1843 * The updater methods are used to update column values in the
1844 * current row or the insert row. The updater methods do not
1845 * update the underlying database; instead the <code>updateRow</code>
1846 * or <code>insertRow</code> methods are called to update the database.
1847 *
1848 * @param columnName the name of the column
1849 * @param x the new column value
1850 * @exception SQLException if a database access error occurs
1851 * @since 1.2
1852 */
1853 public void updateBytes(String columnName, byte x[]) throws SQLException {
1854 resultSet.updateBytes(columnName, x);
1855 }
1856
1857 /***
1858 * Updates the designated column with a <code>java.sql.Date</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 columnName the name of the column
1865 * @param x the new column value
1866 * @exception SQLException if a database access error occurs
1867 * @since 1.2
1868 */
1869 public void updateDate(String columnName, java.sql.Date x) throws SQLException {
1870 resultSet.updateDate(columnName, x);
1871 }
1872
1873 /***
1874 * Updates the designated column with a <code>java.sql.Time</code> value.
1875 * The updater methods are used to update column values in the
1876 * current row or the insert row. The updater methods do not
1877 * update the underlying database; instead the <code>updateRow</code> or
1878 * <code>insertRow</code> methods are called to update the database.
1879 *
1880 * @param columnName the name of the column
1881 * @param x the new column value
1882 * @exception SQLException if a database access error occurs
1883 * @since 1.2
1884 */
1885 public void updateTime(String columnName, java.sql.Time x) throws SQLException {
1886 resultSet.updateTime(columnName, x);
1887 }
1888
1889 /***
1890 * Updates the designated column with a <code>java.sql.Timestamp</code>
1891 * value.
1892 * The updater methods are used to update column values in the
1893 * current row or the insert row. The updater methods do not
1894 * update the underlying database; instead the <code>updateRow</code> or
1895 * <code>insertRow</code> methods are called to update the database.
1896 *
1897 * @param columnName the name of the column
1898 * @param x the new column value
1899 * @exception SQLException if a database access error occurs
1900 * @since 1.2
1901 */
1902 public void updateTimestamp(String columnName, java.sql.Timestamp x)
1903 throws SQLException {
1904 resultSet.updateTimestamp(columnName, x);
1905 }
1906
1907 /***
1908 * Updates the designated column with an ascii stream value.
1909 * The updater methods are used to update column values in the
1910 * current row or the insert row. The updater methods do not
1911 * update the underlying database; instead the <code>updateRow</code> or
1912 * <code>insertRow</code> methods are called to update the database.
1913 *
1914 * @param columnName the name of the column
1915 * @param x the new column value
1916 * @param length the length of the stream
1917 * @exception SQLException if a database access error occurs
1918 * @since 1.2
1919 */
1920 public void updateAsciiStream(String columnName,
1921 java.io.InputStream x,
1922 int length) throws SQLException {
1923 resultSet.updateAsciiStream(columnName, x, length);
1924 }
1925
1926 /***
1927 * Updates the designated column with a binary stream value.
1928 * The updater methods are used to update column values in the
1929 * current row or the insert row. The updater methods do not
1930 * update the underlying database; instead the <code>updateRow</code> or
1931 * <code>insertRow</code> methods are called to update the database.
1932 *
1933 * @param columnName the name of the column
1934 * @param x the new column value
1935 * @param length the length of the stream
1936 * @exception SQLException if a database access error occurs
1937 * @since 1.2
1938 */
1939 public void updateBinaryStream(String columnName,
1940 java.io.InputStream x,
1941 int length) throws SQLException {
1942 resultSet.updateBinaryStream(columnName, x, length);
1943 }
1944
1945 /***
1946 * Updates the designated column with a character stream value.
1947 * The updater methods are used to update column values in the
1948 * current row or the insert row. The updater methods do not
1949 * update the underlying database; instead the <code>updateRow</code> or
1950 * <code>insertRow</code> methods are called to update the database.
1951 *
1952 * @param columnName the name of the column
1953 * @param reader the <code>java.io.Reader</code> object containing
1954 * the new column value
1955 * @param length the length of the stream
1956 * @exception SQLException if a database access error occurs
1957 * @since 1.2
1958 */
1959 public void updateCharacterStream(String columnName,
1960 java.io.Reader reader,
1961 int length) throws SQLException {
1962 resultSet.updateCharacterStream(columnName, reader, length);
1963 }
1964
1965 /***
1966 * Updates the designated column with an <code>Object</code> value.
1967 * The updater methods are used to update column values in the
1968 * current row or the insert row. The updater methods do not
1969 * update the underlying database; instead the <code>updateRow</code> or
1970 * <code>insertRow</code> methods are called to update the database.
1971 *
1972 * @param columnName the name of the column
1973 * @param x the new column value
1974 * @param scale for <code>java.sql.Types.DECIMAL</code>
1975 * or <code>java.sql.Types.NUMERIC</code> types,
1976 * this is the number of digits after the decimal point. For all other
1977 * types this value will be ignored.
1978 * @exception SQLException if a database access error occurs
1979 * @since 1.2
1980 */
1981 public void updateObject(String columnName, Object x, int scale)
1982 throws SQLException {
1983 resultSet.updateObject(columnName, x, scale);
1984 }
1985
1986 /***
1987 * Updates the designated column with an <code>Object</code> value.
1988 * The updater methods are used to update column values in the
1989 * current row or the insert row. The updater methods do not
1990 * update the underlying database; instead the <code>updateRow</code> or
1991 * <code>insertRow</code> methods are called to update the database.
1992 *
1993 * @param columnName the name of the column
1994 * @param x the new column value
1995 * @exception SQLException if a database access error occurs
1996 * @since 1.2
1997 */
1998 public void updateObject(String columnName, Object x) throws SQLException {
1999 resultSet.updateObject(columnName, x);
2000 }
2001
2002 /***
2003 * Inserts the contents of the insert row into this
2004 * <code>ResultSet</code> object and into the database.
2005 * The cursor must be on the insert row when this method is called.
2006 *
2007 * @exception SQLException if a database access error occurs,
2008 * if this method is called when the cursor is not on the insert row,
2009 * or if not all of non-nullable columns in
2010 * the insert row have been given a value
2011 * @since 1.2
2012 */
2013 public void insertRow() throws SQLException {
2014 resultSet.insertRow();
2015 }
2016
2017 /***
2018 * Updates the underlying database with the new contents of the
2019 * current row of this <code>ResultSet</code> object.
2020 * This method cannot be called when the cursor is on the insert row.
2021 *
2022 * @exception SQLException if a database access error occurs or
2023 * if this method is called when the cursor is on the insert row
2024 * @since 1.2
2025 */
2026 public void updateRow() throws SQLException {
2027 resultSet.updateRow();
2028 }
2029
2030 /***
2031 * Deletes the current row from this <code>ResultSet</code> object
2032 * and from the underlying database. This method cannot be called when
2033 * the cursor is on the insert row.
2034 *
2035 * @exception SQLException if a database access error occurs
2036 * or if this method is called when the cursor is on the insert row
2037 * @since 1.2
2038 */
2039 public void deleteRow() throws SQLException {
2040 resultSet.deleteRow();
2041 }
2042
2043 /***
2044 * Refreshes the current row with its most recent value in
2045 * the database. This method cannot be called when
2046 * the cursor is on the insert row.
2047 *
2048 * <P>The <code>refreshRow</code> method provides a way for an
2049 * application to
2050 * explicitly tell the JDBC driver to refetch a row(s) from the
2051 * database. An application may want to call <code>refreshRow</code> when
2052 * caching or prefetching is being done by the JDBC driver to
2053 * fetch the latest value of a row from the database. The JDBC driver
2054 * may actually refresh multiple rows at once if the fetch size is
2055 * greater than one.
2056 *
2057 * <P> All values are refetched subject to the transaction isolation
2058 * level and cursor sensitivity. If <code>refreshRow</code> is called after
2059 * calling an updater method, but before calling
2060 * the method <code>updateRow</code>, then the
2061 * updates made to the row are lost. Calling the method
2062 * <code>refreshRow</code> frequently will likely slow performance.
2063 *
2064 * @exception SQLException if a database access error
2065 * occurs or if this method is called when the cursor is on the insert row
2066 * @since 1.2
2067 */
2068 public void refreshRow() throws SQLException {
2069 resultSet.refreshRow();
2070 }
2071
2072 /***
2073 * Cancels the updates made to the current row in this
2074 * <code>ResultSet</code> object.
2075 * This method may be called after calling an
2076 * updater method(s) and before calling
2077 * the method <code>updateRow</code> to roll back
2078 * the updates made to a row. If no updates have been made or
2079 * <code>updateRow</code> has already been called, this method has no
2080 * effect.
2081 *
2082 * @exception SQLException if a database access error
2083 * occurs or if this method is called when the cursor is
2084 * on the insert row
2085 * @since 1.2
2086 */
2087 public void cancelRowUpdates() throws SQLException {
2088 resultSet.cancelRowUpdates();
2089 }
2090
2091 /***
2092 * Moves the cursor to the insert row. The current cursor position is
2093 * remembered while the cursor is positioned on the insert row.
2094 *
2095 * The insert row is a special row associated with an updatable
2096 * result set. It is essentially a buffer where a new row may
2097 * be constructed by calling the updater methods prior to
2098 * inserting the row into the result set.
2099 *
2100 * Only the updater, getter,
2101 * and <code>insertRow</code> methods may be
2102 * called when the cursor is on the insert row. All of the columns in
2103 * a result set must be given a value each time this method is
2104 * called before calling <code>insertRow</code>.
2105 * An updater method must be called before a
2106 * getter method can be called on a column value.
2107 *
2108 * @exception SQLException if a database access error occurs
2109 * or the result set is not updatable
2110 * @since 1.2
2111 */
2112 public void moveToInsertRow() throws SQLException {
2113 resultSet.moveToInsertRow();
2114 }
2115
2116 /***
2117 * Moves the cursor to the remembered cursor position, usually the
2118 * current row. This method has no effect if the cursor is not on
2119 * the insert row.
2120 *
2121 * @exception SQLException if a database access error occurs
2122 * or the result set is not updatable
2123 * @since 1.2
2124 */
2125 public void moveToCurrentRow() throws SQLException {
2126 resultSet.moveToCurrentRow();
2127 }
2128
2129 /***
2130 * Retrieves the <code>Statement</code> object that produced this
2131 * <code>ResultSet</code> object.
2132 * If the result set was generated some other way, such as by a
2133 * <code>DatabaseMetaData</code> method, this method returns
2134 * <code>null</code>.
2135 *
2136 * @return the <code>Statment</code> object that produced
2137 * this <code>ResultSet</code> object or <code>null</code>
2138 * if the result set was produced some other way
2139 * @exception SQLException if a database access error occurs
2140 * @since 1.2
2141 */
2142 public Statement getStatement() throws SQLException {
2143 return resultSet.getStatement();
2144 }
2145
2146 /***
2147 * Retrieves the value of the designated column in the current row
2148 * of this <code>ResultSet</code> object as an <code>Object</code>
2149 * in the Java programming language.
2150 * If the value is an SQL <code>NULL</code>,
2151 * the driver returns a Java <code>null</code>.
2152 * This method uses the given <code>Map</code> object
2153 * for the custom mapping of the
2154 * SQL structured or distinct type that is being retrieved.
2155 *
2156 * @param i the first column is 1, the second is 2, ...
2157 * @param map a <code>java.util.Map</code> object that contains the mapping
2158 * from SQL type names to classes in the Java programming language
2159 * @return an <code>Object</code> in the Java programming language
2160 * representing the SQL value
2161 * @exception SQLException if a database access error occurs
2162 * @since 1.2
2163 */
2164 public Object getObject(int i, java.util.Map map) throws SQLException {
2165 return resultSet.getObject(i, map);
2166 }
2167
2168 /***
2169 * Retrieves the value of the designated column in the current row
2170 * of this <code>ResultSet</code> object as a <code>Ref</code> object
2171 * in the Java programming language.
2172 *
2173 * @param i the first column is 1, the second is 2, ...
2174 * @return a <code>Ref</code> object representing an SQL <code>REF</code>
2175 * value
2176 * @exception SQLException if a database access error occurs
2177 * @since 1.2
2178 */
2179 public Ref getRef(int i) throws SQLException {
2180 return resultSet.getRef(i);
2181 }
2182
2183 /***
2184 * Retrieves the value of the designated column in the current row
2185 * of this <code>ResultSet</code> object as a <code>Blob</code> object
2186 * in the Java programming language.
2187 *
2188 * @param i the first column is 1, the second is 2, ...
2189 * @return a <code>Blob</code> object representing the SQL
2190 * <code>BLOB</code> value in the specified column
2191 * @exception SQLException if a database access error occurs
2192 * @since 1.2
2193 */
2194 public Blob getBlob(int i) throws SQLException {
2195 return resultSet.getBlob(i);
2196 }
2197
2198 /***
2199 * Retrieves the value of the designated column in the current row
2200 * of this <code>ResultSet</code> object as a <code>Clob</code> object
2201 * in the Java programming language.
2202 *
2203 * @param i the first column is 1, the second is 2, ...
2204 * @return a <code>Clob</code> object representing the SQL
2205 * <code>CLOB</code> value in the specified column
2206 * @exception SQLException if a database access error occurs
2207 * @since 1.2
2208 */
2209 public Clob getClob(int i) throws SQLException {
2210 return resultSet.getClob(i);
2211 }
2212
2213 /***
2214 * Retrieves the value of the designated column in the current row
2215 * of this <code>ResultSet</code> object as an <code>Array</code> object
2216 * in the Java programming language.
2217 *
2218 * @param i the first column is 1, the second is 2, ...
2219 * @return an <code>Array</code> object representing the SQL
2220 * <code>ARRAY</code> value in the specified column
2221 * @exception SQLException if a database access error occurs
2222 * @since 1.2
2223 */
2224 public Array getArray(int i) throws SQLException {
2225 return resultSet.getArray(i);
2226 }
2227
2228 /***
2229 * Retrieves the value of the designated column in the current row
2230 * of this <code>ResultSet</code> object as an <code>Object</code>
2231 * in the Java programming language.
2232 * If the value is an SQL <code>NULL</code>,
2233 * the driver returns a Java <code>null</code>.
2234 * This method uses the specified <code>Map</code> object for
2235 * custom mapping if appropriate.
2236 *
2237 * @param colName the name of the column from which to retrieve the value
2238 * @param map a <code>java.util.Map</code> object that contains the mapping
2239 * from SQL type names to classes in the Java programming language
2240 * @return an <code>Object</code> representing the SQL value in the
2241 * specified column
2242 * @exception SQLException if a database access error occurs
2243 * @since 1.2
2244 */
2245 public Object getObject(String colName, java.util.Map map) throws SQLException {
2246 return resultSet.getObject(colName, map);
2247 }
2248
2249 /***
2250 * Retrieves the value of the designated column in the current row
2251 * of this <code>ResultSet</code> object as a <code>Ref</code> object
2252 * in the Java programming language.
2253 *
2254 * @param colName the column name
2255 * @return a <code>Ref</code> object representing the SQL <code>REF</code>
2256 * value in the specified column
2257 * @exception SQLException if a database access error occurs
2258 * @since 1.2
2259 */
2260 public Ref getRef(String colName) throws SQLException {
2261 return resultSet.getRef(colName);
2262 }
2263
2264 /***
2265 * Retrieves the value of the designated column in the current row
2266 * of this <code>ResultSet</code> object as a <code>Blob</code> object
2267 * in the Java programming language.
2268 *
2269 * @param colName the name of the column from which to retrieve the value
2270 * @return a <code>Blob</code> object representing the SQL <code>BLOB</code>
2271 * value in the specified column
2272 * @exception SQLException if a database access error occurs
2273 * @since 1.2
2274 */
2275 public Blob getBlob(String colName) throws SQLException {
2276 return resultSet.getBlob(colName);
2277 }
2278
2279 /***
2280 * Retrieves the value of the designated column in the current row
2281 * of this <code>ResultSet</code> object as a <code>Clob</code> object
2282 * in the Java programming language.
2283 *
2284 * @param colName the name of the column from which to retrieve the value
2285 * @return a <code>Clob</code> object representing the SQL <code>CLOB</code>
2286 * value in the specified column
2287 * @exception SQLException if a database access error occurs
2288 * @since 1.2
2289 */
2290 public Clob getClob(String colName) throws SQLException {
2291 return resultSet.getClob(colName);
2292 }
2293
2294 /***
2295 * Retrieves the value of the designated column in the current row
2296 * of this <code>ResultSet</code> object as an <code>Array</code> object
2297 * in the Java programming language.
2298 *
2299 * @param colName the name of the column from which to retrieve the value
2300 * @return an <code>Array</code> object representing the SQL <code>ARRAY</code> value in
2301 * the specified column
2302 * @exception SQLException if a database access error occurs
2303 * @since 1.2
2304 */
2305 public Array getArray(String colName) throws SQLException {
2306 return resultSet.getArray(colName);
2307 }
2308
2309 /***
2310 * Retrieves the value of the designated column in the current row
2311 * of this <code>ResultSet</code> object as a <code>java.sql.Date</code> object
2312 * in the Java programming language.
2313 * This method uses the given calendar to construct an appropriate millisecond
2314 * value for the date if the underlying database does not store
2315 * timezone information.
2316 *
2317 * @param columnIndex the first column is 1, the second is 2, ...
2318 * @param cal the <code>java.util.Calendar</code> object
2319 * to use in constructing the date
2320 * @return the column value as a <code>java.sql.Date</code> object;
2321 * if the value is SQL <code>NULL</code>,
2322 * the value returned is <code>null</code> in the Java programming language
2323 * @exception SQLException if a database access error occurs
2324 * @since 1.2
2325 */
2326 public java.sql.Date getDate(int columnIndex, Calendar cal) throws SQLException {
2327 return resultSet.getDate(columnIndex, cal);
2328 }
2329
2330 /***
2331 * Retrieves the value of the designated column in the current row
2332 * of this <code>ResultSet</code> object as a <code>java.sql.Date</code> object
2333 * in the Java programming language.
2334 * This method uses the given calendar to construct an appropriate millisecond
2335 * value for the date if the underlying database does not store
2336 * timezone information.
2337 *
2338 * @param columnName the SQL name of the column from which to retrieve the value
2339 * @param cal the <code>java.util.Calendar</code> object
2340 * to use in constructing the date
2341 * @return the column value as a <code>java.sql.Date</code> object;
2342 * if the value is SQL <code>NULL</code>,
2343 * the value returned is <code>null</code> in the Java programming language
2344 * @exception SQLException if a database access error occurs
2345 * @since 1.2
2346 */
2347 public java.sql.Date getDate(String columnName, Calendar cal) throws SQLException {
2348 return resultSet.getDate(columnName, cal);
2349 }
2350
2351 /***
2352 * Retrieves the value of the designated column in the current row
2353 * of this <code>ResultSet</code> object as a <code>java.sql.Time</code> object
2354 * in the Java programming language.
2355 * This method uses the given calendar to construct an appropriate millisecond
2356 * value for the time if the underlying database does not store
2357 * timezone information.
2358 *
2359 * @param columnIndex the first column is 1, the second is 2, ...
2360 * @param cal the <code>java.util.Calendar</code> object
2361 * to use in constructing the time
2362 * @return the column value as a <code>java.sql.Time</code> object;
2363 * if the value is SQL <code>NULL</code>,
2364 * the value returned is <code>null</code> in the Java programming language
2365 * @exception SQLException if a database access error occurs
2366 * @since 1.2
2367 */
2368 public java.sql.Time getTime(int columnIndex, Calendar cal) throws SQLException {
2369 return resultSet.getTime(columnIndex, cal);
2370 }
2371
2372 /***
2373 * Retrieves the value of the designated column in the current row
2374 * of this <code>ResultSet</code> object as a <code>java.sql.Time</code> object
2375 * in the Java programming language.
2376 * This method uses the given calendar to construct an appropriate millisecond
2377 * value for the time if the underlying database does not store
2378 * timezone information.
2379 *
2380 * @param columnName the SQL name of the column
2381 * @param cal the <code>java.util.Calendar</code> object
2382 * to use in constructing the time
2383 * @return the column value as a <code>java.sql.Time</code> object;
2384 * if the value is SQL <code>NULL</code>,
2385 * the value returned is <code>null</code> in the Java programming language
2386 * @exception SQLException if a database access error occurs
2387 * @since 1.2
2388 */
2389 public java.sql.Time getTime(String columnName, Calendar cal) throws SQLException {
2390 return resultSet.getTime(columnName, cal);
2391 }
2392
2393 /***
2394 * Retrieves the value of the designated column in the current row
2395 * of this <code>ResultSet</code> object as a <code>java.sql.Timestamp</code> object
2396 * in the Java programming language.
2397 * This method uses the given calendar to construct an appropriate millisecond
2398 * value for the timestamp if the underlying database does not store
2399 * timezone information.
2400 *
2401 * @param columnIndex the first column is 1, the second is 2, ...
2402 * @param cal the <code>java.util.Calendar</code> object
2403 * to use in constructing the timestamp
2404 * @return the column value as a <code>java.sql.Timestamp</code> object;
2405 * if the value is SQL <code>NULL</code>,
2406 * the value returned is <code>null</code> in the Java programming language
2407 * @exception SQLException if a database access error occurs
2408 * @since 1.2
2409 */
2410 public java.sql.Timestamp getTimestamp(int columnIndex, Calendar cal)
2411 throws SQLException {
2412 return resultSet.getTimestamp(columnIndex, cal);
2413 }
2414
2415 /***
2416 * Retrieves the value of the designated column in the current row
2417 * of this <code>ResultSet</code> object as a <code>java.sql.Timestamp</code> object
2418 * in the Java programming language.
2419 * This method uses the given calendar to construct an appropriate millisecond
2420 * value for the timestamp if the underlying database does not store
2421 * timezone information.
2422 *
2423 * @param columnName the SQL name of the column
2424 * @param cal the <code>java.util.Calendar</code> object
2425 * to use in constructing the date
2426 * @return the column value as a <code>java.sql.Timestamp</code> object;
2427 * if the value is SQL <code>NULL</code>,
2428 * the value returned is <code>null</code> in the Java programming language
2429 * @exception SQLException if a database access error occurs
2430 * @since 1.2
2431 */
2432 public java.sql.Timestamp getTimestamp(String columnName, Calendar cal)
2433 throws SQLException {
2434 return resultSet.getTimestamp(columnName, cal);
2435 }
2436
2437
2438
2439 /***
2440 * Retrieves the value of the designated column in the current row
2441 * of this <code>ResultSet</code> object as a <code>java.net.URL</code>
2442 * object in the Java programming language.
2443 *
2444 * @param columnIndex the index of the column 1 is the first, 2 is the second,...
2445 * @return the column value as a <code>java.net.URL</code> object;
2446 * if the value is SQL <code>NULL</code>,
2447 * the value returned is <code>null</code> in the Java programming language
2448 * @exception SQLException if a database access error occurs,
2449 * or if a URL is malformed
2450 * @since 1.4
2451 */
2452 public java.net.URL getURL(int columnIndex) throws SQLException {
2453 return resultSet.getURL(columnIndex);
2454 }
2455
2456 /***
2457 * Retrieves the value of the designated column in the current row
2458 * of this <code>ResultSet</code> object as a <code>java.net.URL</code>
2459 * object in the Java programming language.
2460 *
2461 * @param columnName the SQL name of the column
2462 * @return the column value as a <code>java.net.URL</code> object;
2463 * if the value is SQL <code>NULL</code>,
2464 * the value returned is <code>null</code> in the Java programming language
2465 * @exception SQLException if a database access error occurs
2466 * or if a URL is malformed
2467 * @since 1.4
2468 */
2469 public java.net.URL getURL(String columnName) throws SQLException {
2470 return resultSet.getURL(columnName);
2471 }
2472
2473 /***
2474 * Updates the designated column with a <code>java.sql.Ref</code> value.
2475 * The updater methods are used to update column values in the
2476 * current row or the insert row. The updater methods do not
2477 * update the underlying database; instead the <code>updateRow</code> or
2478 * <code>insertRow</code> methods are called to update the database.
2479 *
2480 * @param columnIndex the first column is 1, the second is 2, ...
2481 * @param x the new column value
2482 * @exception SQLException if a database access error occurs
2483 * @since 1.4
2484 */
2485 public void updateRef(int columnIndex, java.sql.Ref x) throws SQLException {
2486 resultSet.updateRef(columnIndex, x);
2487 }
2488
2489 /***
2490 * Updates the designated column with a <code>java.sql.Ref</code> value.
2491 * The updater methods are used to update column values in the
2492 * current row or the insert row. The updater methods do not
2493 * update the underlying database; instead the <code>updateRow</code> or
2494 * <code>insertRow</code> methods are called to update the database.
2495 *
2496 * @param columnName the name of the column
2497 * @param x the new column value
2498 * @exception SQLException if a database access error occurs
2499 * @since 1.4
2500 */
2501 public void updateRef(String columnName, java.sql.Ref x) throws SQLException {
2502 resultSet.updateRef(columnName, x);
2503 }
2504
2505 /***
2506 * Updates the designated column with a <code>java.sql.Blob</code> value.
2507 * The updater methods are used to update column values in the
2508 * current row or the insert row. The updater methods do not
2509 * update the underlying database; instead the <code>updateRow</code> or
2510 * <code>insertRow</code> methods are called to update the database.
2511 *
2512 * @param columnIndex the first column is 1, the second is 2, ...
2513 * @param x the new column value
2514 * @exception SQLException if a database access error occurs
2515 * @since 1.4
2516 */
2517 public void updateBlob(int columnIndex, java.sql.Blob x) throws SQLException {
2518 resultSet.updateBlob(columnIndex, x);
2519 }
2520
2521 /***
2522 * Updates the designated column with a <code>java.sql.Blob</code> value.
2523 * The updater methods are used to update column values in the
2524 * current row or the insert row. The updater methods do not
2525 * update the underlying database; instead the <code>updateRow</code> or
2526 * <code>insertRow</code> methods are called to update the database.
2527 *
2528 * @param columnName the name of the column
2529 * @param x the new column value
2530 * @exception SQLException if a database access error occurs
2531 * @since 1.4
2532 */
2533 public void updateBlob(String columnName, java.sql.Blob x) throws SQLException {
2534 resultSet.updateBlob(columnName, x);
2535 }
2536
2537 /***
2538 * Updates the designated column with a <code>java.sql.Clob</code> value.
2539 * The updater methods are used to update column values in the
2540 * current row or the insert row. The updater methods do not
2541 * update the underlying database; instead the <code>updateRow</code> or
2542 * <code>insertRow</code> methods are called to update the database.
2543 *
2544 * @param columnIndex the first column is 1, the second is 2, ...
2545 * @param x the new column value
2546 * @exception SQLException if a database access error occurs
2547 * @since 1.4
2548 */
2549 public void updateClob(int columnIndex, java.sql.Clob x) throws SQLException {
2550 resultSet.updateClob(columnIndex, x);
2551 }
2552
2553 /***
2554 * Updates the designated column with a <code>java.sql.Clob</code> value.
2555 * The updater methods are used to update column values in the
2556 * current row or the insert row. The updater methods do not
2557 * update the underlying database; instead the <code>updateRow</code> or
2558 * <code>insertRow</code> methods are called to update the database.
2559 *
2560 * @param columnName the name of the column
2561 * @param x the new column value
2562 * @exception SQLException if a database access error occurs
2563 * @since 1.4
2564 */
2565 public void updateClob(String columnName, java.sql.Clob x) throws SQLException {
2566 resultSet.updateClob(columnName, x);
2567 }
2568
2569 /***
2570 * Updates the designated column with a <code>java.sql.Array</code> value.
2571 * The updater methods are used to update column values in the
2572 * current row or the insert row. The updater methods do not
2573 * update the underlying database; instead the <code>updateRow</code> or
2574 * <code>insertRow</code> methods are called to update the database.
2575 *
2576 * @param columnIndex the first column is 1, the second is 2, ...
2577 * @param x the new column value
2578 * @exception SQLException if a database access error occurs
2579 * @since 1.4
2580 */
2581 public void updateArray(int columnIndex, java.sql.Array x) throws SQLException {
2582 resultSet.updateArray(columnIndex, x);
2583 }
2584
2585 /***
2586 * Updates the designated column with a <code>java.sql.Array</code> value.
2587 * The updater methods are used to update column values in the
2588 * current row or the insert row. The updater methods do not
2589 * update the underlying database; instead the <code>updateRow</code> or
2590 * <code>insertRow</code> methods are called to update the database.
2591 *
2592 * @param columnName the name of the column
2593 * @param x the new column value
2594 * @exception SQLException if a database access error occurs
2595 * @since 1.4
2596 */
2597 public void updateArray(String columnName, java.sql.Array x) throws SQLException {
2598 resultSet.updateArray(columnName, x);
2599 }
2600 }