View Javadoc

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