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