View Javadoc

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