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