001    /*
002     $Id: GroovyResultSet.java,v 1.5 2004/03/26 18:54:09 jstrachan Exp $
003    
004     Copyright 2003 (C) James Strachan and Bob Mcwhirter. All Rights Reserved.
005    
006     Redistribution and use of this software and associated documentation
007     ("Software"), with or without modification, are permitted provided
008     that the following conditions are met:
009    
010     1. Redistributions of source code must retain copyright
011        statements and notices.  Redistributions must also contain a
012        copy of this document.
013    
014     2. Redistributions in binary form must reproduce the
015        above copyright notice, this list of conditions and the
016        following disclaimer in the documentation and/or other
017        materials provided with the distribution.
018    
019     3. The name "groovy" must not be used to endorse or promote
020        products derived from this Software without prior written
021        permission of The Codehaus.  For written permission,
022        please contact info@codehaus.org.
023    
024     4. Products derived from this Software may not be called "groovy"
025        nor may "groovy" appear in their names without prior written
026        permission of The Codehaus. "groovy" is a registered
027        trademark of The Codehaus.
028    
029     5. Due credit should be given to The Codehaus -
030        http://groovy.codehaus.org/
031    
032     THIS SOFTWARE IS PROVIDED BY THE CODEHAUS AND CONTRIBUTORS
033     ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
034     NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
035     FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
036     THE CODEHAUS OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
037     INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
038     (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
039     SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
040     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
041     STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
042     ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
043     OF THE POSSIBILITY OF SUCH DAMAGE.
044    
045     */
046    package groovy.sql;
047    
048    import groovy.lang.GroovyObjectSupport;
049    import groovy.lang.MissingPropertyException;
050    
051    import java.math.BigDecimal;
052    import java.sql.Array;
053    import java.sql.Blob;
054    import java.sql.Clob;
055    import java.sql.Ref;
056    import java.sql.ResultSet;
057    import java.sql.ResultSetMetaData;
058    import java.sql.SQLException;
059    import java.sql.SQLWarning;
060    import java.sql.Statement;
061    import java.util.Calendar;
062    import java.util.Iterator;
063    import java.util.Map;
064    
065    /**
066     * Represents an extent of objects
067     * 
068     * @Author Chris Stevenson
069     * @author <a href="mailto:james@coredevelopers.net">James Strachan</a>
070     * @author <a href="mailto:ivan_ganza@yahoo.com">Ivan Ganza</a>
071     * @version $Revision: 1.5 $
072     */
073    public class GroovyResultSet extends GroovyObjectSupport implements ResultSet {
074    
075        private ResultSet resultSet;
076        private boolean updated;
077    
078        public GroovyResultSet(ResultSet resultSet) {
079            this.resultSet = resultSet;
080        }
081    
082        public Object getProperty(String property) {
083            try {
084                return resultSet.getObject(property);
085            }
086            catch (SQLException e) {
087                throw new MissingPropertyException(property, GroovyResultSet.class, e);
088            }
089        }
090    
091        public void setProperty(String property, Object newValue) {
092            try {
093                resultSet.updateObject(property, newValue);
094                updated = true;
095            }
096            catch (SQLException e) {
097                throw new MissingPropertyException(property, GroovyResultSet.class, e);
098            }
099        }
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    }