View Javadoc

1   /*
2    $Id: GroovyResultSet.java,v 1.6 2006/04/09 15:16:53 glaforge Exp $
3   
4    Copyright 2003 (C) James Strachan and Bob Mcwhirter. All Rights Reserved.
5   
6    Redistribution and use of this software and associated documentation
7    ("Software"), with or without modification, are permitted provided
8    that the following conditions are met:
9   
10   1. Redistributions of source code must retain copyright
11      statements and notices.  Redistributions must also contain a
12      copy of this document.
13  
14   2. Redistributions in binary form must reproduce the
15      above copyright notice, this list of conditions and the
16      following disclaimer in the documentation and/or other
17      materials provided with the distribution.
18  
19   3. The name "groovy" must not be used to endorse or promote
20      products derived from this Software without prior written
21      permission of The Codehaus.  For written permission,
22      please contact info@codehaus.org.
23  
24   4. Products derived from this Software may not be called "groovy"
25      nor may "groovy" appear in their names without prior written
26      permission of The Codehaus. "groovy" is a registered
27      trademark of The Codehaus.
28  
29   5. Due credit should be given to The Codehaus -
30      http://groovy.codehaus.org/
31  
32   THIS SOFTWARE IS PROVIDED BY THE CODEHAUS AND CONTRIBUTORS
33   ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
34   NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
35   FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
36   THE CODEHAUS OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
37   INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
38   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
39   SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
40   HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
41   STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
42   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
43   OF THE POSSIBILITY OF SUCH DAMAGE.
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     // Implementation of java.sql.getResultSet()
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     // Methods for accessing results by column index
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     // Methods for accessing results by column name
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     // Advanced features:
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     //--------------------------JDBC 2.0-----------------------------------
948 
949     //---------------------------------------------------------------------
950     // Getters and Setters
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     // Traversal/Positioning
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     // Updates
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     //-------------------------- JDBC 3.0 ----------------------------------------
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 }