/*
    * Copyright (c) 1998, 2005 Gargoyle Software Inc. All rights reserved.
    *
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions are met:
    *
    * 1. Redistributions of source code must retain the above copyright notice,
    *    this list of conditions and the following disclaimer.
    * 2. Redistributions in binary form must reproduce the above copyright notice,
   *    this list of conditions and the following disclaimer in the documentation
   *    and/or other materials provided with the distribution.
   * 3. The end-user documentation included with the redistribution, if any, must
   *    include the following acknowledgment:
   *
   *       "This product includes software developed by Gargoyle Software Inc.
   *        (http://www.GargoyleSoftware.com/)."
   *
   *    Alternately, this acknowledgment may appear in the software itself, if
   *    and wherever such third-party acknowledgments normally appear.
   * 4. The name "Gargoyle Software" must not be used to endorse or promote
   *    products derived from this software without prior written permission.
   *    For written permission, please contact info@GargoyleSoftware.com.
   * 5. Products derived from this software may not be called "GSBase", nor may
   *    "GSBase" appear in their name, without prior written permission of
   *    Gargoyle Software Inc.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
   * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
   * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GARGOYLE
   * SOFTWARE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
   * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
   * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
   * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
   * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  package com.gargoylesoftware.base.resource.jdbc;
  
  import java.math.BigDecimal;
  import java.sql.Array;
  import java.sql.Blob;
  import java.sql.Clob;
  import java.sql.Ref;
  import java.sql.ResultSet;
  import java.sql.ResultSetMetaData;
  import java.sql.SQLException;
  import java.sql.SQLWarning;
  import java.sql.Statement;
  import java.util.Calendar;
  
  /***
   *  A table of data representing a database result set, which is usually
   *  generated by executing a statement that queries the database. <P>
   *
   *  A <code>ResultSet</code> object maintains a cursor pointing to its current
   *  row of data. Initially the cursor is positioned before the first row. The
   *  <code>next</code> method moves the cursor to the next row, and because it
   *  returns <code>false</code> when there are no more rows in the <code>ResultSet</code>
   *  object, it can be used in a <code>while</code> loop to iterate through the
   *  result set. <P>
   *
   *  A default <code>ResultSet</code> object is not updatable and has a cursor
   *  that moves forward only. Thus, it is possible to iterate through it only
   *  once and only from the first row to the last row. New methods in the JDBC
   *  2.0 API make it possible to produce <code>ResultSet</code> objects that are
   *  scrollable and/or updatable. The following code fragment, in which <code>con</code>
   *  is a valid <code>Connection</code> object, illustrates how to make a result
   *  set that is scrollable and insensitive to updates by others, and that is
   *  updatable. See <code>ResultSet</code> fields for other options. <PRE>
   *
   *       Statement stmt = con.createStatement(
   *                                      ResultSet.TYPE_SCROLL_INSENSITIVE,
   *                                      ResultSet.CONCUR_UPDATABLE);
   *       ResultSet rs = stmt.executeQuery("SELECT a, b FROM TABLE2");
   *       // rs will be scrollable, will not show changes made by others,
   *       // and will be updatable
   *
   * </PRE> The <code>ResultSet</code> interface provides <code>getXXX</code>
   *  methods for retrieving column values from the current row. Values can be
   *  retrieved using either the index number of the column or the name of the
   *  column. In general, using the column index will be more efficient. Columns
   *  are numbered from 1. For maximum portability, result set columns within each
   *  row should be read in left-to-right order, and each column should be read
   *  only once. <P>
   *
   *  For the <code>getXXX</code> methods, a JDBC driver attempts to convert the
   *  underlying data to the Java type specified in the <code>XXX</code> part of
   *  the <code>getXXX</code> method and returns a suitable Java value. The JDBC
   *  specification has a table showing the allowable mappings from SQL types to
   *  Java types with the <code>ResultSet.getXXX</code> methods. <P>
   *
   *  <P>
   *
   *  Column names used as input to <code>getXXX</code> methods are case
   *  insensitive. When a <code>getXXX</code> method is called with a column name
   *  and several columns have the same name, the value of the first matching
   *  column will be returned. The column name option is designed to be used when
   *  column names are used in the SQL query that generated the result set. For
  *  columns that are NOT explicitly named in the query, it is best to use column
  *  numbers. If column names are used, there is no way for the programmer to
  *  guarantee that they actually refer to the intended columns. <P>
  *
  *  A set of <code>updateXXX</code> methods were added to this interface in the
  *  JDBC 2.0 API (Java<sup><font size=-2>TM</font> </sup> 2 SDK, Standard
  *  Edition, version 1.2). The comments regarding parameters to the <code>getXXX</code>
  *  methods also apply to parameters to the <code>updateXXX</code> methods. <P>
  *
  *  The <code>updateXXX</code> methods may be used in two ways:
  *  <ol>
  *    <LI> to update a column value in the current row. In a scrollable <code>ResultSet</code>
  *    object, the cursor can be moved backwards and forwards, to an absolute
  *    position, or to a position relative to the current row. The following code
  *    fragment updates the <code>NAME</code> column in the fifth row of the
  *    <code>ResultSet</code> object <code>rs</code> and then uses the method
  *    <code>updateRow</code> to update the data source table from which <code>rs</code>
  *    was derived. <PRE>
  *
  *       rs.absolute(5); // moves the cursor to the fifth row of rs
  *       rs.updateString("NAME", "AINSWORTH"); // updates the
  *          // <code>NAME</code> column of row 5 to be <code>AINSWORTH</code>
  *    rs.updateRow(); // updates the row in the data source </PRE>
  *    <LI> to insert column values into the insert row. An updatable <code>ResultSet</code>
  *    object has a special row associated with it that serves as a staging area
  *    for building a row to be inserted. The following code fragment moves the
  *    cursor to the insert row, builds a three-column row, and inserts it into
  *    <code>rs</code> and into the data source table using the method <code>insertRow</code>
  *    . <PRE>
  *
  *       rs.moveToInsertRow(); // moves cursor to the insert row
  *       rs.updateString(1, "AINSWORTH"); // updates the
  *          // first column of the insert row to be <code>AINSWORTH</code>
  *    rs.updateInt(2,35); // updates the second column to be <code>35</code>
  *    rs.updateBoolean(3, true); // updates the third row to <code>true</code>
  *    rs.insertRow(); rs.moveToCurrentRow(); </PRE>
  *  </ol>
  *  <P>
  *
  *  A <code>ResultSet</code> object is automatically closed when the <code>Statement</code>
  *  object that generated it is closed, re-executed, or used to retrieve the
  *  next result from a sequence of multiple results. <P>
  *
  *  The number, types and properties of a <code>ResultSet</code> object's
  *  columns are provided by the <code>ResulSetMetaData</code> object returned by
  *  the <code>ResultSet.getMetaData</code> method.
  *
  * @version  $Revision: 1.4 $
  * @author <a href="mailto:mbowler@GargoyleSoftware.com">Mike Bowler</a>
  */
 public final class ResultSetWrapper implements ResultSet {
 
     private ResultSet delegate_;
     private boolean isOpen_ = true;
 
 
     /***
      *  Create a wrapper
      *
      * @param  resultSet The resultSet that we are wrapping
      */
     public ResultSetWrapper( final ResultSet resultSet ) {
         if( resultSet == null ) {
             throw new NullPointerException( "resultSet" );
         }
         delegate_ = resultSet;
     }
 
 
     /***
      *  Gives a hint as to the direction in which the rows in this <code>ResultSet</code>
      *  object will be processed. The initial value is determined by the <code>Statement</code>
      *  object that produced this <code>ResultSet</code> object. The fetch
      *  direction may be changed at any time.
      *
      * @param  direction The direction
      * @exception  SQLException if a database access error occurs or the result
      *      set type is <code>TYPE_FORWARD_ONLY</code> and the fetch direction
      *      is not <code>FETCH_FORWARD</code>
      * @since  1.2
      */
     public final void setFetchDirection( int direction )
         throws SQLException {
         checkIsOpen();
         delegate_.setFetchDirection( direction );
     }
 
 
     /***
      *  Gives the JDBC driver a hint as to the number of rows that should be
      *  fetched from the database when more rows are needed for this <code>ResultSet</code>
      *  object. If the fetch size specified is zero, the JDBC driver ignores the
      *  value and is free to make its own best guess as to what the fetch size
      *  should be. The default value is set by the <code>Statement</code> object
      *  that created the result set. The fetch size may be changed at any time.
      *
      * @param  rows the number of rows to fetch
      * @exception  SQLException if a database access error occurs or the
      *      condition <code>0 <= rows <= this.getMaxRows()</code> is not
      *      satisfied
      * @since  1.2
      */
     public final void setFetchSize( int rows )
         throws SQLException {
         checkIsOpen();
         delegate_.setFetchSize( rows );
     }
 
 
     /***
      *  Return the wrapped object
      *
      * @return  The wrapped object
      */
     public final ResultSet getDelegate() {
         return delegate_;
     }
 
 
     /***
      *  Return true if this object is closed
      *
      * @return  true if this object is closed
      */
     public final boolean isClosed() {
         return isOpen_ == false;
     }
 
     //======================================================================
     // Methods for accessing results by column index
     //======================================================================
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>String</code> in the Java
      *  programming language.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @return  the column value; if the value is SQL <code>NULL</code>, the
      *      value returned is <code>null</code>
      * @exception  SQLException if a database access error occurs
      */
     public final String getString( int columnIndex )
         throws SQLException {
         checkIsOpen();
         return delegate_.getString( columnIndex );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>boolean</code> in the Java
      *  programming language.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @return  the column value; if the value is SQL <code>NULL</code>, the
      *      value returned is <code>false</code>
      * @exception  SQLException if a database access error occurs
      */
     public final boolean getBoolean( int columnIndex )
         throws SQLException {
         checkIsOpen();
         return delegate_.getBoolean( columnIndex );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>byte</code> in the Java
      *  programming language.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @return  the column value; if the value is SQL <code>NULL</code>, the
      *      value returned is <code>0</code>
      * @exception  SQLException if a database access error occurs
      */
     public final byte getByte( int columnIndex )
         throws SQLException {
         checkIsOpen();
         return delegate_.getByte( columnIndex );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>short</code> in the Java
      *  programming language.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @return  the column value; if the value is SQL <code>NULL</code>, the
      *      value returned is <code>0</code>
      * @exception  SQLException if a database access error occurs
      */
     public final short getShort( int columnIndex )
         throws SQLException {
         checkIsOpen();
         return delegate_.getShort( columnIndex );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as an <code>int</code> in the Java
      *  programming language.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @return  the column value; if the value is SQL <code>NULL</code>, the
      *      value returned is <code>0</code>
      * @exception  SQLException if a database access error occurs
      */
     public final int getInt( int columnIndex )
         throws SQLException {
         checkIsOpen();
         return delegate_.getInt( columnIndex );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>long</code> in the Java
      *  programming language.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @return  the column value; if the value is SQL <code>NULL</code>, the
      *      value returned is <code>0</code>
      * @exception  SQLException if a database access error occurs
      */
     public final long getLong( int columnIndex )
         throws SQLException {
         checkIsOpen();
         return delegate_.getLong( columnIndex );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>float</code> in the Java
      *  programming language.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @return  the column value; if the value is SQL <code>NULL</code>, the
      *      value returned is <code>0</code>
      * @exception  SQLException if a database access error occurs
      */
     public final float getFloat( int columnIndex )
         throws SQLException {
         checkIsOpen();
         return delegate_.getFloat( columnIndex );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>double</code> in the Java
      *  programming language.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @return  the column value; if the value is SQL <code>NULL</code>, the
      *      value returned is <code>0</code>
      * @exception  SQLException if a database access error occurs
      */
     public final double getDouble( int columnIndex )
         throws SQLException {
         checkIsOpen();
         return delegate_.getDouble( columnIndex );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>java.sql.BigDecimal</code> in
      *  the Java programming language.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @param  scale the number of digits to the right of the decimal point
      * @return  the column value; if the value is SQL <code>NULL</code>, the
      *      value returned is <code>null</code>
      * @exception  SQLException if a database access error occurs
      * @deprecated
      */
     public final BigDecimal getBigDecimal( int columnIndex, int scale )
         throws SQLException {
         checkIsOpen();
         return delegate_.getBigDecimal( columnIndex, scale );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>byte</code> array in the Java
      *  programming language. The bytes represent the raw values returned by the
      *  driver.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @return  the column value; if the value is SQL <code>NULL</code>, the
      *      value returned is <code>null</code>
      * @exception  SQLException if a database access error occurs
      */
     public final byte[] getBytes( int columnIndex )
         throws SQLException {
         checkIsOpen();
         return delegate_.getBytes( columnIndex );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>java.sql.Date</code> object in
      *  the Java programming language.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @return  the column value; if the value is SQL <code>NULL</code>, the
      *      value returned is <code>null</code>
      * @exception  SQLException if a database access error occurs
      */
     public final java.sql.Date getDate( int columnIndex )
         throws SQLException {
         checkIsOpen();
         return delegate_.getDate( columnIndex );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>java.sql.Time</code> object in
      *  the Java programming language.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @return  the column value; if the value is SQL <code>NULL</code>, the
      *      value returned is <code>null</code>
      * @exception  SQLException if a database access error occurs
      */
     public final java.sql.Time getTime( int columnIndex )
         throws SQLException {
         checkIsOpen();
         return delegate_.getTime( columnIndex );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>java.sql.Timestamp</code>
      *  object in the Java programming language.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @return  the column value; if the value is SQL <code>NULL</code>, the
      *      value returned is <code>null</code>
      * @exception  SQLException if a database access error occurs
      */
     public final java.sql.Timestamp getTimestamp( int columnIndex )
         throws SQLException {
         checkIsOpen();
         return delegate_.getTimestamp( columnIndex );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a stream of ASCII characters. The value
      *  can then be read in chunks from the stream. This method is particularly
      *  suitable for retrieving large <char>LONGVARCHAR</char> values. The JDBC
      *  driver will do any necessary conversion from the database format into
      *  ASCII. <P>
      *
      *  <B>Note:</B> All the data in the returned stream must be read prior to
      *  getting the value of any other column. The next call to a <code>getXXX</code>
      *  method implicitly closes the stream. Also, a stream may return <code>0</code>
      *  when the method <code>InputStream.available</code> is called whether
      *  there is data available or not.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @return  a Java input stream that delivers the database column value as a
      *      stream of one-byte ASCII characters; if the value is SQL <code>NULL</code>
      *      , the value returned is <code>null</code>
      * @exception  SQLException if a database access error occurs
      */
     public final java.io.InputStream getAsciiStream( int columnIndex )
         throws SQLException {
         checkIsOpen();
         return delegate_.getAsciiStream( columnIndex );
     }
 
 
     /***
      *  Gets the value of a column in the current row as a stream of Gets the
      *  value of the designated column in the current row of this <code>ResultSet</code>
      *  object as as a stream of Unicode characters. The value can then be read
      *  in chunks from the stream. This method is particularly suitable for
      *  retrieving large<code>LONGVARCHAR</code>values. The JDBC driver will do
      *  any necessary conversion from the database format into Unicode. The byte
      *  format of the Unicode stream must be Java UTF-8, as specified in the
      *  Java virtual machine specification. <P>
      *
      *  <B>Note:</B> All the data in the returned stream must be read prior to
      *  getting the value of any other column. The next call to a <code>getXXX</code>
      *  method implicitly closes the stream. Also, a stream may return <code>0</code>
      *  when the method <code>InputStream.available</code> is called whether
      *  there is data available or not.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @return  a Java input stream that delivers the database column value as a
      *      stream in Java UTF-8 byte format; if the value is SQL <code>NULL</code>
      *      , the value returned is <code>null</code>
      * @exception  SQLException if a database access error occurs
      * @deprecated  use <code>getCharacterStream</code> in place of <code>getUnicodeStream</code>
      */
     public final java.io.InputStream getUnicodeStream( int columnIndex )
         throws SQLException {
         checkIsOpen();
         return delegate_.getUnicodeStream( columnIndex );
     }
 
 
     /***
      *  Gets the value of a column in the current row as a stream of Gets the
      *  value of the designated column in the current row of this <code>ResultSet</code>
      *  object as a binary stream of uninterpreted bytes. The value can then be
      *  read in chunks from the stream. This method is particularly suitable for
      *  retrieving large <code>LONGVARBINARY</code> values. <P>
      *
      *  <B>Note:</B> All the data in the returned stream must be read prior to
      *  getting the value of any other column. The next call to a <code>getXXX</code>
      *  method implicitly closes the stream. Also, a stream may return <code>0</code>
      *  when the method <code>InputStream.available</code> is called whether
      *  there is data available or not.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @return  a Java input stream that delivers the database column value as a
      *      stream of uninterpreted bytes; if the value is SQL <code>NULL</code>
      *      , the value returned is <code>null</code>
      * @exception  SQLException if a database access error occurs
      */
     public final java.io.InputStream getBinaryStream( int columnIndex )
         throws SQLException {
         checkIsOpen();
         return delegate_.getBinaryStream( columnIndex );
     }
 
 
     //======================================================================
     // Methods for accessing results by column name
     //======================================================================
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>String</code> in the Java
      *  programming language.
      *
      * @param  columnName the SQL name of the column
      * @return  the column value; if the value is SQL <code>NULL</code>, the
      *      value returned is <code>null</code>
      * @exception  SQLException if a database access error occurs
      */
     public final String getString( String columnName )
         throws SQLException {
         checkIsOpen();
         return delegate_.getString( columnName );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>boolean</code> in the Java
      *  programming language.
      *
      * @param  columnName the SQL name of the column
      * @return  the column value; if the value is SQL <code>NULL</code>, the
      *      value returned is <code>false</code>
      * @exception  SQLException if a database access error occurs
      */
     public final boolean getBoolean( String columnName )
         throws SQLException {
         checkIsOpen();
         return delegate_.getBoolean( columnName );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>byte</code> in the Java
      *  programming language.
      *
      * @param  columnName the SQL name of the column
      * @return  the column value; if the value is SQL <code>NULL</code>, the
      *      value returned is <code>0</code>
      * @exception  SQLException if a database access error occurs
      */
     public final byte getByte( String columnName )
         throws SQLException {
         checkIsOpen();
         return delegate_.getByte( columnName );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>short</code> in the Java
      *  programming language.
      *
      * @param  columnName the SQL name of the column
      * @return  the column value; if the value is SQL <code>NULL</code>, the
      *      value returned is <code>0</code>
      * @exception  SQLException if a database access error occurs
      */
     public final short getShort( String columnName )
         throws SQLException {
         checkIsOpen();
         return delegate_.getShort( columnName );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as an <code>int</code> in the Java
      *  programming language.
      *
      * @param  columnName the SQL name of the column
      * @return  the column value; if the value is SQL <code>NULL</code>, the
      *      value returned is <code>0</code>
      * @exception  SQLException if a database access error occurs
      */
     public final int getInt( String columnName )
         throws SQLException {
         checkIsOpen();
         return delegate_.getInt( columnName );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>long</code> in the Java
      *  programming language.
      *
      * @param  columnName the SQL name of the column
      * @return  the column value; if the value is SQL <code>NULL</code>, the
      *      value returned is <code>0</code>
      * @exception  SQLException if a database access error occurs
      */
     public final long getLong( String columnName )
         throws SQLException {
         checkIsOpen();
         return delegate_.getLong( columnName );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>float</code> in the Java
      *  programming language.
      *
      * @param  columnName the SQL name of the column
      * @return  the column value; if the value is SQL <code>NULL</code>, the
      *      value returned is <code>0</code>
      * @exception  SQLException if a database access error occurs
      */
     public final float getFloat( String columnName )
         throws SQLException {
         checkIsOpen();
         return delegate_.getFloat( columnName );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>double</code> in the Java
      *  programming language.
      *
      * @param  columnName the SQL name of the column
      * @return  the column value; if the value is SQL <code>NULL</code>, the
      *      value returned is <code>0</code>
      * @exception  SQLException if a database access error occurs
      */
     public final double getDouble( String columnName )
         throws SQLException {
         checkIsOpen();
         return delegate_.getDouble( columnName );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>java.math.BigDecimal</code> in
      *  the Java programming language.
      *
      * @param  columnName the SQL name of the column
      * @param  scale the number of digits to the right of the decimal point
      * @return  the column value; if the value is SQL <code>NULL</code>, the
      *      value returned is <code>null</code>
      * @exception  SQLException if a database access error occurs
      * @deprecated
      */
     public final BigDecimal getBigDecimal( String columnName, int scale )
         throws SQLException {
         checkIsOpen();
         return delegate_.getBigDecimal( columnName, scale );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>byte</code> array in the Java
      *  programming language. The bytes represent the raw values returned by the
      *  driver.
      *
      * @param  columnName the SQL name of the column
      * @return  the column value; if the value is SQL <code>NULL</code>, the
      *      value returned is <code>null</code>
      * @exception  SQLException if a database access error occurs
      */
     public final byte[] getBytes( String columnName )
         throws SQLException {
         checkIsOpen();
         return delegate_.getBytes( columnName );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>java.sql.Date</code> object in
      *  the Java programming language.
      *
      * @param  columnName the SQL name of the column
      * @return  the column value; if the value is SQL <code>NULL</code>, the
      *      value returned is <code>null</code>
      * @exception  SQLException if a database access error occurs
      */
     public final java.sql.Date getDate( String columnName )
         throws SQLException {
         checkIsOpen();
         return delegate_.getDate( columnName );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>java.sql.Time</code> object in
      *  the Java programming language.
      *
      * @param  columnName the SQL name of the column
      * @return  the column value; if the value is SQL <code>NULL</code>, the
      *      value returned is <code>null</code>
      * @exception  SQLException if a database access error occurs
      */
     public final java.sql.Time getTime( String columnName )
         throws SQLException {
         checkIsOpen();
         return delegate_.getTime( columnName );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>java.sql.Timestamp</code>
      *  object.
      *
      * @param  columnName the SQL name of the column
      * @return  the column value; if the value is SQL <code>NULL</code>, the
      *      value returned is <code>null</code>
      * @exception  SQLException if a database access error occurs
      */
     public final java.sql.Timestamp getTimestamp( String columnName )
         throws SQLException {
         checkIsOpen();
         return delegate_.getTimestamp( columnName );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a stream of ASCII characters. The value
      *  can then be read in chunks from the stream. This method is particularly
      *  suitable for retrieving large <code>LONGVARCHAR</code> values. The JDBC
      *  driver will do any necessary conversion from the database format into
      *  ASCII. <P>
      *
      *  <B>Note:</B> All the data in the returned stream must be read prior to
      *  getting the value of any other column. The next call to a <code>getXXX</code>
      *  method implicitly closes the stream. Also, a stream may return <code>0</code>
      *  when the method <code>available</code> is called whether there is data
      *  available or not.
      *
      * @param  columnName the SQL name of the column
      * @return  a Java input stream that delivers the database column value as a
      *      stream of one-byte ASCII characters. If the value is SQL <code>NULL</code>
      *      , the value returned is <code>null</code>.
      * @exception  SQLException if a database access error occurs
      */
     public final java.io.InputStream getAsciiStream( String columnName )
         throws SQLException {
         checkIsOpen();
         return delegate_.getAsciiStream( columnName );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a stream of Unicode characters. The
      *  value can then be read in chunks from the stream. This method is
      *  particularly suitable for retrieving large <code>LONGVARCHAR</code>
      *  values. The JDBC driver will do any necessary conversion from the
      *  database format into Unicode. The byte format of the Unicode stream must
      *  be Java UTF-8, as defined in the Java virtual machine specification. <P>
      *
      *  <B>Note:</B> All the data in the returned stream must be read prior to
      *  getting the value of any other column. The next call to a <code>getXXX</code>
      *  method implicitly closes the stream. Also, a stream may return <code>0</code>
      *  when the method <code>available</code> is called whether there is data
      *  available or not.
      *
      * @param  columnName the SQL name of the column
      * @return  a Java input stream that delivers the database column value as a
      *      stream of two-byte Unicode characters. If the value is SQL <code>NULL</code>
      *      , the value returned is <code>null</code>.
      * @exception  SQLException if a database access error occurs
      * @deprecated
      */
     public final java.io.InputStream getUnicodeStream( String columnName )
         throws SQLException {
         checkIsOpen();
         return delegate_.getUnicodeStream( columnName );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a stream of uninterpreted <code>byte</code>
      *  s. The value can then be read in chunks from the stream. This method is
      *  particularly suitable for retrieving large <code>LONGVARBINARY</code>
      *  values. <P>
      *
      *  <B>Note:</B> All the data in the returned stream must be read prior to
      *  getting the value of any other column. The next call to a <code>getXXX</code>
      *  method implicitly closes the stream. Also, a stream may return <code>0</code>
      *  when the method <code>available</code> is called whether there is data
      *  available or not.
      *
      * @param  columnName the SQL name of the column
      * @return  a Java input stream that delivers the database column value as a
      *      stream of uninterpreted bytes; if the value is SQL <code>NULL</code>
      *      , the result is <code>null</code>
      * @exception  SQLException if a database access error occurs
      */
     public final java.io.InputStream getBinaryStream( String columnName )
         throws SQLException {
         checkIsOpen();
         return delegate_.getBinaryStream( columnName );
     }
 
 
     //=====================================================================
     // Advanced features:
     //=====================================================================
 
     /***
      *  Returns the first warning reported by calls on this <code>ResultSet</code>
      *  object. Subsequent warnings on this <code>ResultSet</code> object will
      *  be chained to the <code>SQLWarning</code> object that this method
      *  returns. <P>
      *
      *  The warning chain is automatically cleared each time a new row is read.
      *  <P>
      *
      *  <B>Note:</B> This warning chain only covers warnings caused by <code>ResultSet</code>
      *  methods. Any warning caused by <code>Statement</code> methods (such as
      *  reading OUT parameters) will be chained on the <code>Statement</code>
      *  object.
      *
      * @return  the first <code>SQLWarning</code> object reported or <code>null</code>
      * @exception  SQLException if a database access error occurs
      */
     public final SQLWarning getWarnings()
         throws SQLException {
         checkIsOpen();
         return delegate_.getWarnings();
     }
 
 
     /***
      *  Gets the name of the SQL cursor used by this <code>ResultSet</code>
      *  object. <P>
      *
      *  In SQL, a result table is retrieved through a cursor that is named. The
      *  current row of a result set can be updated or deleted using a positioned
      *  update/delete statement that references the cursor name. To insure that
      *  the cursor has the proper isolation level to support update, the
      *  cursor's <code>select</code> statement should be of the form 'select for
      *  update'. If the 'for update' clause is omitted, the positioned updates
      *  may fail. <P>
      *
      *  The JDBC API supports this SQL feature by providing the name of the SQL
      *  cursor used by a <code>ResultSet</code> object. The current row of a
      *  <code>ResultSet</code> object is also the current row of this SQL
      *  cursor. <P>
      *
      *  <B>Note:</B> If positioned update is not supported, a <code>SQLException</code>
      *  is thrown.
      *
      * @return  the SQL name for this <code>ResultSet</code> object's cursor
      * @exception  SQLException if a database access error occurs
      */
     public final String getCursorName()
         throws SQLException {
         checkIsOpen();
         return delegate_.getCursorName();
     }
 
 
     /***
      *  Retrieves the number, types and properties of this <code>ResultSet</code>
      *  object's columns.
      *
      * @return  the description of this <code>ResultSet</code> object's columns
      * @exception  SQLException if a database access error occurs
      */
     public final ResultSetMetaData getMetaData()
         throws SQLException {
         checkIsOpen();
         return delegate_.getMetaData();
     }
 
 
     /***
      *  <p>
      *
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as an <code>Object</code> in the Java
      *  programming language. <p>
      *
      *  This method will return the value of the given column as a Java object.
      *  The type of the Java object will be the default Java object type
      *  corresponding to the column's SQL type, following the mapping for
      *  built-in types specified in the JDBC specification. <p>
      *
      *  This method may also be used to read datatabase-specific abstract data
      *  types. In the JDBC 2.0 API, the behavior of method <code>getObject</code>
      *  is extended to materialize data of SQL user-defined types. When a column
      *  contains a structured or distinct value, the behavior of this method is
      *  as if it were a call to: <code>getObject(columnIndex,
      * this.getStatement().getConnection().getTypeMap())</code>.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @return  a <code>java.lang.Object</code> holding the column value
      * @exception  SQLException if a database access error occurs
      */
     public final Object getObject( int columnIndex )
         throws SQLException {
         checkIsOpen();
         return delegate_.getObject( columnIndex );
     }
 
 
     /***
      *  <p>
      *
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as an <code>Object</code> in the Java
      *  programming language. <p>
      *
      *  This method will return the value of the given column as a Java object.
      *  The type of the Java object will be the default Java object type
      *  corresponding to the column's SQL type, following the mapping for
      *  built-in types specified in the JDBC specification. <p>
      *
      *  This method may also be used to read datatabase-specific abstract data
      *  types. In the JDBC 2.0 API, the behavior of the method <code>getObject</code>
      *  is extended to materialize data of SQL user-defined types. When a column
      *  contains a structured or distinct value, the behavior of this method is
      *  as if it were a call to: <code>getObject(columnIndex,
      * this.getStatement().getConnection().getTypeMap())</code>.
      *
      * @param  columnName the SQL name of the column
      * @return  a <code>java.lang.Object</code> holding the column value
      * @exception  SQLException if a database access error occurs
      */
     public final Object getObject( String columnName )
         throws SQLException {
         checkIsOpen();
         return delegate_.getObject( columnName );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>java.io.Reader</code> object.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @return  a <code>java.io.Reader</code> object that contains the column
      *      value; if the value is SQL <code>NULL</code>, the value returned is
      *      <code>null</code> in the Java programming language.
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final java.io.Reader getCharacterStream( int columnIndex )
         throws SQLException {
         checkIsOpen();
         return delegate_.getCharacterStream( columnIndex );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>java.io.Reader</code> object.
      *
      * @param  columnName the name of the column
      * @return  a <code>java.io.Reader</code> object that contains the column
      *      value; if the value is SQL <code>NULL</code>, the value returned is
      *      <code>null</code> in the Java programming language.
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final java.io.Reader getCharacterStream( String columnName )
         throws SQLException {
         checkIsOpen();
         return delegate_.getCharacterStream( columnName );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>java.math.BigDecimal</code>
      *  with full precision.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @return  the column value (full precision); if the value is SQL <code>NULL</code>
      *      , the value returned is <code>null</code> in the Java programming
      *      language.
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final BigDecimal getBigDecimal( int columnIndex )
         throws SQLException {
         checkIsOpen();
         return delegate_.getBigDecimal( columnIndex );
     }
 
 
     /***
      *  Gets the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>java.math.BigDecimal</code>
      *  with full precision.
      *
      * @param  columnName the column name
      * @return  the column value (full precision); if the value is SQL <code>NULL</code>
      *      , the value returned is <code>null</code> in the Java programming
      *      language.
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final BigDecimal getBigDecimal( String columnName )
         throws SQLException {
         checkIsOpen();
         return delegate_.getBigDecimal( columnName );
     }
 
     //---------------------------------------------------------------------
     // Traversal/Positioning
     //---------------------------------------------------------------------
 
     /***
      *  Indicates whether the cursor is before the first row in this <code>ResultSet</code>
      *  object.
      *
      * @return  <code>true</code> if the cursor is before the first row; <code>false</code>
      *      if the cursor is at any other position or the result set contains no
      *      rows
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final boolean isBeforeFirst()
         throws SQLException {
         checkIsOpen();
         return delegate_.isBeforeFirst();
     }
 
 
     /***
      *  Indicates whether the cursor is after the last row in this <code>ResultSet</code>
      *  object.
      *
      * @return  <code>true</code> if the cursor is after the last row; <code>false</code>
      *      if the cursor is at any other position or the result set contains no
      *      rows
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final boolean isAfterLast()
         throws SQLException {
         checkIsOpen();
         return delegate_.isAfterLast();
     }
 
 
     /***
      *  Indicates whether the cursor is on the first row of this <code>ResultSet</code>
      *  object.
      *
      * @return  <code>true</code> if the cursor is on the first row; <code>false</code>
      *      otherwise
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final boolean isFirst()
         throws SQLException {
         checkIsOpen();
         return delegate_.isFirst();
     }
 
 
     /***
      *  Indicates whether the cursor is on the last row of this <code>ResultSet</code>
      *  object. Note: Calling the method <code>isLast</code> may be expensive
      *  because the JDBC driver might need to fetch ahead one row in order to
      *  determine whether the current row is the last row in the result set.
      *
      * @return  <code>true</code> if the cursor is on the last row; <code>false</code>
      *      otherwise
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final boolean isLast()
         throws SQLException {
         checkIsOpen();
         return delegate_.isLast();
     }
 
 
     /***
      *  Retrieves the current row number. The first row is number 1, the second
      *  number 2, and so on.
      *
      * @return  the current row number; <code>0</code> if there is no current
      *      row
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final int getRow()
         throws SQLException {
         checkIsOpen();
         return delegate_.getRow();
     }
 
 
     /***
      *  Returns the fetch direction for this <code>ResultSet</code> object.
      *
      * @return  the current fetch direction for this <code>ResultSet</code>
      *      object
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final int getFetchDirection()
         throws SQLException {
         checkIsOpen();
         return delegate_.getFetchDirection();
     }
 
 
     /***
      *  Returns the fetch size for this <code>ResultSet</code> object.
      *
      * @return  the current fetch size for this <code>ResultSet</code> object
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final int getFetchSize()
         throws SQLException {
         checkIsOpen();
         return delegate_.getFetchSize();
     }
 
 
     /***
      *  Returns the type of this <code>ResultSet</code> object. The type is
      *  determined by the <code>Statement</code> object that created the result
      *  set.
      *
      * @return  <code>TYPE_FORWARD_ONLY</code>, <code>TYPE_SCROLL_INSENSITIVE</code>
      *      , or <code>TYPE_SCROLL_SENSITIVE</code>
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final int getType()
         throws SQLException {
         checkIsOpen();
         return delegate_.getType();
     }
 
 
     /***
      *  Returns the concurrency mode of this <code>ResultSet</code> object. The
      *  concurrency used is determined by the <code>Statement</code> object that
      *  created the result set.
      *
      * @return  the concurrency type, either <code>CONCUR_READ_ONLY</code> or
      *      <code>CONCUR_UPDATABLE</code>
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final int getConcurrency()
         throws SQLException {
         checkIsOpen();
         return delegate_.getConcurrency();
     }
 
 
     /***
      *  Returns the <code>Statement</code> object that produced this <code>ResultSet</code>
      *  object. If the result set was generated some other way, such as by a
      *  <code>DatabaseMetaData</code> method, this method returns <code>null</code>
      *  .
      *
      * @return  the <code>Statment</code> object that produced this <code>ResultSet</code>
      *      object or <code>null</code> if the result set was produced some
      *      other way
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final Statement getStatement()
         throws SQLException {
         checkIsOpen();
         return delegate_.getStatement();
     }
 
 
     /***
      *  Returns the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as an <code>Object</code> in the Java
      *  programming language. This method uses the given <code>Map</code> object
      *  for the custom mapping of the SQL structured or distinct type that is
      *  being retrieved.
      *
      * @param  i the first column is 1, the second is 2, ...
      * @param  map a <code>java.util.Map</code> object that contains the mapping
      *      from SQL type names to classes in the Java programming language
      * @return  an <code>Object</code> in the Java programming language
      *      representing the SQL value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final Object getObject( int i, java.util.Map map )
         throws SQLException {
         checkIsOpen();
         return delegate_.getObject( i, map );
     }
 
 
     /***
      *  Returns the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>Ref</code> object in the Java
      *  programming language.
      *
      * @param  i the first column is 1, the second is 2, ...
      * @return  a <code>Ref</code> object representing an SQL <code>REF</code>
      *      value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final Ref getRef( int i )
         throws SQLException {
         checkIsOpen();
         return delegate_.getRef( i );
     }
 
 
     /***
      *  Returns the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>Blob</code> object in the Java
      *  programming language.
      *
      * @param  i the first column is 1, the second is 2, ...
      * @return  a <code>Blob</code> object representing the SQL <code>BLOB</code>
      *      value in the specified column
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final Blob getBlob( int i )
         throws SQLException {
         checkIsOpen();
         return delegate_.getBlob( i );
     }
 
 
     /***
      *  Returns the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>Clob</code> object in the Java
      *  programming language.
      *
      * @param  i the first column is 1, the second is 2, ...
      * @return  a <code>Clob</code> object representing the SQL <code>CLOB</code>
      *      value in the specified column
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final Clob getClob( int i )
         throws SQLException {
         checkIsOpen();
         return delegate_.getClob( i );
     }
 
 
     /***
      *  Returns the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as an <code>Array</code> object in the
      *  Java programming language.
      *
      * @param  i the first column is 1, the second is 2, ...
      * @return  an <code>Array</code> object representing the SQL <code>ARRAY</code>
      *      value in the specified column
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final Array getArray( int i )
         throws SQLException {
         checkIsOpen();
         return delegate_.getArray( i );
     }
 
 
     /***
      *  Returns the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as an <code>Object</code> in the Java
      *  programming language. This method uses the specified <code>Map</code>
      *  object for custom mapping if appropriate.
      *
      * @param  colName the name of the column from which to retrieve the value
      * @param  map a <code>java.util.Map</code> object that contains the mapping
      *      from SQL type names to classes in the Java programming language
      * @return  an <code>Object</code> representing the SQL value in the
      *      specified column
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final Object getObject( String colName, java.util.Map map )
         throws SQLException {
         checkIsOpen();
         return delegate_.getObject( colName, map );
     }
 
 
     /***
      *  Returns the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>Ref</code> object in the Java
      *  programming language.
      *
      * @param  colName the column name
      * @return  a <code>Ref</code> object representing the SQL <code>REF</code>
      *      value in the specified column
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final Ref getRef( String colName )
         throws SQLException {
         checkIsOpen();
         return delegate_.getRef( colName );
     }
 
 
     /***
      *  Returns the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>Blob</code> object in the Java
      *  programming language.
      *
      * @param  colName the name of the column from which to retrieve the value
      * @return  a <code>Blob</code> object representing the SQL <code>BLOB</code>
      *      value in the specified column
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final Blob getBlob( String colName )
         throws SQLException {
         checkIsOpen();
         return delegate_.getBlob( colName );
     }
 
 
     /***
      *  Returns the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>Clob</code> object in the Java
      *  programming language.
      *
      * @param  colName the name of the column from which to retrieve the value
      * @return  a <code>Clob</code> object representing the SQL <code>CLOB</code>
      *      value in the specified column
      * @since  1.2
      * @exception  SQLException if a database access error occurs
      */
     public final Clob getClob( String colName )
         throws SQLException {
         checkIsOpen();
         return delegate_.getClob( colName );
     }
 
 
     /***
      *  Returns the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as an <code>Array</code> object in the
      *  Java programming language.
      *
      * @param  colName the name of the column from which to retrieve the value
      * @return  an <code>Array</code> object representing the SQL <code>ARRAY</code>
      *      value in the specified column
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final Array getArray( String colName )
         throws SQLException {
         checkIsOpen();
         return delegate_.getArray( colName );
     }
 
 
     /***
      *  Returns the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>java.sql.Date</code> object in
      *  the Java programming language. This method uses the given calendar to
      *  construct an appropriate millisecond value for the date if the
      *  underlying database does not store timezone information.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @param  cal the <code>java.util.Calendar</code> object to use in
      *      constructing the date
      * @return  the column value as a <code>java.sql.Date</code> object; if the
      *      value is SQL <code>NULL</code>, the value returned is <code>null</code>
      *      in the Java programming language
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final java.sql.Date getDate( int columnIndex, Calendar cal )
         throws SQLException {
         checkIsOpen();
         return delegate_.getDate( columnIndex, cal );
     }
 
 
     /***
      *  Returns the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>java.sql.Date</code> object in
      *  the Java programming language. This method uses the given calendar to
      *  construct an appropriate millisecond value for the date if the
      *  underlying database does not store timezone information.
      *
      * @param  columnName the SQL name of the column from which to retrieve the
      *      value
      * @param  cal the <code>java.util.Calendar</code> object to use in
      *      constructing the date
      * @return  the column value as a <code>java.sql.Date</code> object; if the
      *      value is SQL <code>NULL</code>, the value returned is <code>null</code>
      *      in the Java programming language
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final java.sql.Date getDate( String columnName, Calendar cal )
         throws SQLException {
         checkIsOpen();
         return delegate_.getDate( columnName, cal );
     }
 
 
     /***
      *  Returns the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>java.sql.Time</code> object in
      *  the Java programming language. This method uses the given calendar to
      *  construct an appropriate millisecond value for the time if the
      *  underlying database does not store timezone information.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @param  cal the <code>java.util.Calendar</code> object to use in
      *      constructing the time
      * @return  the column value as a <code>java.sql.Time</code> object; if the
      *      value is SQL <code>NULL</code>, the value returned is <code>null</code>
      *      in the Java programming language
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final java.sql.Time getTime( int columnIndex, Calendar cal )
         throws SQLException {
         checkIsOpen();
         return delegate_.getTime( columnIndex, cal );
     }
 
 
     /***
      *  Returns the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>java.sql.Time</code> object in
      *  the Java programming language. This method uses the given calendar to
      *  construct an appropriate millisecond value for the time if the
      *  underlying database does not store timezone information.
      *
      * @param  columnName the SQL name of the column
      * @param  cal the <code>java.util.Calendar</code> object to use in
      *      constructing the time
      * @return  the column value as a <code>java.sql.Time</code> object; if the
      *      value is SQL <code>NULL</code>, the value returned is <code>null</code>
      *      in the Java programming language
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final java.sql.Time getTime( String columnName, Calendar cal )
         throws SQLException {
         checkIsOpen();
         return delegate_.getTime( columnName, cal );
     }
 
 
     /***
      *  Returns the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>java.sql.Timestamp</code>
      *  object in the Java programming language. This method uses the given
      *  calendar to construct an appropriate millisecond value for the timestamp
      *  if the underlying database does not store timezone information.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @param  cal the <code>java.util.Calendar</code> object to use in
      *      constructing the timestamp
      * @return  the column value as a <code>java.sql.Timestamp</code> object; if
      *      the value is SQL <code>NULL</code>, the value returned is <code>null</code>
      *      in the Java programming language
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final java.sql.Timestamp getTimestamp( int columnIndex, Calendar cal )
         throws SQLException {
         checkIsOpen();
         return delegate_.getTimestamp( columnIndex, cal );
     }
 
 
     /***
      *  Returns the value of the designated column in the current row of this
      *  <code>ResultSet</code> object as a <code>java.sql.Timestamp</code>
      *  object in the Java programming language. This method uses the given
      *  calendar to construct an appropriate millisecond value for the timestamp
      *  if the underlying database does not store timezone information.
      *
      * @param  columnName the SQL name of the column
      * @param  cal the <code>java.util.Calendar</code> object to use in
      *      constructing the date
      * @return  the column value as a <code>java.sql.Timestamp</code> object; if
      *      the value is SQL <code>NULL</code>, the value returned is <code>null</code>
      *      in the Java programming language
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final java.sql.Timestamp getTimestamp( String columnName, Calendar cal )
         throws SQLException {
         checkIsOpen();
         return delegate_.getTimestamp( columnName, cal );
     }
 
 
     /***
      *  Moves the cursor down one row from its current position. A <code>ResultSet</code>
      *  cursor is initially positioned before the first row; the first call to
      *  the method <code>next</code> makes the first row the current row; the
      *  second call makes the second row the current row, and so on. <P>
      *
      *  If an input stream is open for the current row, a call to the method
      *  <code>next</code> will implicitly close it. A <code>ResultSet</code>
      *  object's warning chain is cleared when a new row is read.
      *
      * @return  <code>true</code> if the new current row is valid; <code>false</code>
      *      if there are no more rows
      * @exception  SQLException if a database access error occurs
      */
     public final boolean next()
         throws SQLException {
         checkIsOpen();
         return delegate_.next();
     }
 
 
     /***
      *  Releases this <code>ResultSet</code> object's database and JDBC
      *  resources immediately instead of waiting for this to happen when it is
      *  automatically closed. <P>
      *
      *  <B>Note:</B> A <code>ResultSet</code> object is automatically closed by
      *  the <code>Statement</code> object that generated it when that <code>Statement</code>
      *  object is closed, re-executed, or is used to retrieve the next result
      *  from a sequence of multiple results. A <code>ResultSet</code> object is
      *  also automatically closed when it is garbage collected.
      *
      * @exception  SQLException if a database access error occurs
      */
     public final void close()
         throws SQLException {
         if( isOpen_ ) {
             delegate_.close();
             delegate_ = null;
             isOpen_ = false;
         }
         else {
             throw new AlreadyClosedException( "resultset already closed" );
         }
     }
 
 
     /***
      *  Reports whether the last column read had a value of SQL <code>NULL</code>
      *  . Note that you must first call one of the <code>getXXX</code> methods
      *  on a column to try to read its value and then call the method <code>wasNull</code>
      *  to see if the value read was SQL <code>NULL</code>.
      *
      * @return  <code>true</code> if the last column value read was SQL <code>NULL</code>
      *      and <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean wasNull()
         throws SQLException {
         checkIsOpen();
         return delegate_.wasNull();
     }
 
 
     /***
      *  Clears all warnings reported on this <code>ResultSet</code> object.
      *  After this method is called, the method <code>getWarnings</code> returns
      *  <code>null</code> until a new warning is reported for this <code>ResultSet</code>
      *  object.
      *
      * @exception  SQLException if a database access error occurs
      */
     public final void clearWarnings()
         throws SQLException {
         checkIsOpen();
         delegate_.clearWarnings();
     }
 
     //----------------------------------------------------------------
 
     /***
      *  Maps the given <code>ResultSet</code> column name to its <code>ResultSet</code>
      *  column index.
      *
      * @param  columnName the name of the column
      * @return  the column index of the given column name
      * @exception  SQLException if a database access error occurs
      */
     public final int findColumn( String columnName )
         throws SQLException {
         checkIsOpen();
         return delegate_.findColumn( columnName );
     }
 
 
     /***
      *  Moves the cursor to the front of this <code>ResultSet</code> object,
      *  just before the first row. This method has no effect if the result set
      *  contains no rows.
      *
      * @exception  SQLException if a database access error occurs or the result
      *      set type is <code>TYPE_FORWARD_ONLY</code>
      * @since  1.2
      */
     public final void beforeFirst()
         throws SQLException {
         checkIsOpen();
         delegate_.beforeFirst();
     }
 
 
     /***
      *  Moves the cursor to the end of this <code>ResultSet</code> object, just
      *  after the last row. This method has no effect if the result set contains
      *  no rows.
      *
      * @exception  SQLException if a database access error occurs or the result
      *      set type is <code>TYPE_FORWARD_ONLY</code>
      * @since  1.2
      */
     public final void afterLast()
         throws SQLException {
         checkIsOpen();
         delegate_.afterLast();
     }
 
 
     /***
      *  Moves the cursor to the first row in this <code>ResultSet</code> object.
      *
      * @return  <code>true</code> if the cursor is on a valid row; <code>false</code>
      *      if there are no rows in the result set
      * @exception  SQLException if a database access error occurs or the result
      *      set type is <code>TYPE_FORWARD_ONLY</code>
      * @since  1.2
      */
     public final boolean first()
         throws SQLException {
         checkIsOpen();
         return delegate_.first();
     }
 
 
     /***
      *  Moves the cursor to the last row in this <code>ResultSet</code> object.
      *
      * @return  <code>true</code> if the cursor is on a valid row; <code>false</code>
      *      if there are no rows in the result set
      * @exception  SQLException if a database access error occurs or the result
      *      set type is <code>TYPE_FORWARD_ONLY</code>
      * @since  1.2
      */
     public final boolean last()
         throws SQLException {
         checkIsOpen();
         return delegate_.last();
     }
 
 
     /***
      *  Moves the cursor to the given row number in this <code>ResultSet</code>
      *  object. <p>
      *
      *  If the row number is positive, the cursor moves to the given row number
      *  with respect to the beginning of the result set. The first row is row 1,
      *  the second is row 2, and so on. <p>
      *
      *  If the given row number is negative, the cursor moves to an absolute row
      *  position with respect to the end of the result set. For example, calling
      *  the method <code>absolute(-1)</code> positions the cursor on the last
      *  row; calling the method <code>absolute(-2)</code> moves the cursor to
      *  the next-to-last row, and so on. <p>
      *
      *  An attempt to position the cursor beyond the first/last row in the
      *  result set leaves the cursor before the first row or after the last row.
      *  <p>
      *
      *  <B>Note:</B> Calling <code>absolute(1)</code> is the same as calling
      *  <code>first()</code>. Calling <code>absolute(-1)</code> is the same as
      *  calling <code>last()</code>.
      *
      * @param  row the row to move to
      * @return  <code>true</code> if the cursor is on the result set; <code>false</code>
      *      otherwise
      * @exception  SQLException if a database access error occurs, the row is
      *      <code>0</code>, or the result set type is <code>TYPE_FORWARD_ONLY</code>
      * @since  1.2
      */
     public final boolean absolute( int row )
         throws SQLException {
         checkIsOpen();
         return delegate_.absolute( row );
     }
 
 
     /***
      *  Moves the cursor a relative number of rows, either positive or negative.
      *  Attempting to move beyond the first/last row in the result set positions
      *  the cursor before/after the the first/last row. Calling <code>relative(0)</code>
      *  is valid, but does not change the cursor position. <p>
      *
      *  Note: Calling the method <code>relative(1)</code> is different from
      *  calling the method <code>next()</code> because is makes sense to call
      *  <code>next()</code> when there is no current row, for example, when the
      *  cursor is positioned before the first row or after the last row of the
      *  result set.
      *
      * @param  rows the number of rows to move
      * @return  <code>true</code> if the cursor is on a row; <code>false</code>
      *      otherwise
      * @exception  SQLException if a database access error occurs, there is no
      *      current row, or the result set type is <code>TYPE_FORWARD_ONLY</code>
      * @since  1.2
      */
     public final boolean relative( int rows )
         throws SQLException {
         checkIsOpen();
         return delegate_.relative( rows );
     }
 
 
     /***
      *  Moves the cursor to the previous row in this <code>ResultSet</code>
      *  object. <p>
      *
      *  <B>Note:</B> Calling the method <code>previous()</code> is not the same
      *  as calling the method <code>relative(-1)</code> because it makes sense
      *  to call</code>previous()</code> when there is no current row.
      *
      * @return  <code>true</code> if the cursor is on a valid row; <code>false</code>
      *      if it is off the result set
      * @exception  SQLException if a database access error occurs or the result
      *      set type is <code>TYPE_FORWARD_ONLY</code>
      * @since  1.2
      */
     public final boolean previous()
         throws SQLException {
         checkIsOpen();
         return delegate_.previous();
     }
 
     //---------------------------------------------------------------------
     // Updates
     //---------------------------------------------------------------------
 
     /***
      *  Indicates whether the current row has been updated. The value returned
      *  depends on whether or not the result set can detect updates.
      *
      * @return  <code>true</code> if the row has been visibly updated by the
      *      owner or another, and updates are detected
      * @exception  SQLException if a database access error occurs
      */
     public final boolean rowUpdated()
         throws SQLException {
         checkIsOpen();
         return delegate_.rowUpdated();
     }
 
 
     /***
      *  Indicates whether the current row has had an insertion. The value
      *  returned depends on whether or not this <code>ResultSet</code> object
      *  can detect visible inserts.
      *
      * @return  <code>true</code> if a row has had an insertion and insertions
      *      are detected; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean rowInserted()
         throws SQLException {
         checkIsOpen();
         return delegate_.rowInserted();
     }
 
 
     /***
      *  Indicates whether a row has been deleted. A deleted row may leave a
      *  visible "hole" in a result set. This method can be used to detect holes
      *  in a result set. The value returned depends on whether or not this
      *  <code>ResultSet</code> object can detect deletions.
      *
      * @return  <code>true</code> if a row was deleted and deletions are
      *      detected; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean rowDeleted()
         throws SQLException {
         checkIsOpen();
         return delegate_.rowDeleted();
     }
 
 
     /***
      *  Gives a nullable column a null value. The <code>updateXXX</code> methods
      *  are used to update column values in the current row or the insert row.
      *  The <code>updateXXX</code> methods do not update the underlying
      *  database; instead the <code>updateRow</code> or <code>insertRow</code>
      *  methods are called to update the database.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateNull( int columnIndex )
         throws SQLException {
         checkIsOpen();
         delegate_.updateNull( columnIndex );
     }
 
 
     /***
      *  Updates the designated column with a <code>boolean</code> value. The
      *  <code>updateXXX</code> methods are used to update column values in the
      *  current row or the insert row. The <code>updateXXX</code> methods do not
      *  update the underlying database; instead the <code>updateRow</code> or
      *  <code>insertRow</code> methods are called to update the database.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateBoolean( int columnIndex, boolean x )
         throws SQLException {
         checkIsOpen();
         delegate_.updateBoolean( columnIndex, x );
     }
 
 
     /***
      *  Updates the designated column with a <code>byte</code> value. The <code>updateXXX</code>
      *  methods are used to update column values in the current row or the
      *  insert row. The <code>updateXXX</code> methods do not update the
      *  underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
      *  methods are called to update the database.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateByte( int columnIndex, byte x )
         throws SQLException {
         checkIsOpen();
         delegate_.updateByte( columnIndex, x );
     }
 
 
     /***
      *  Updates the designated column with a <code>short</code> value. The
      *  <code>updateXXX</code> methods are used to update column values in the
      *  current row or the insert row. The <code>updateXXX</code> methods do not
      *  update the underlying database; instead the <code>updateRow</code> or
      *  <code>insertRow</code> methods are called to update the database.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateShort( int columnIndex, short x )
         throws SQLException {
         checkIsOpen();
         delegate_.updateShort( columnIndex, x );
     }
 
 
     /***
      *  Updates the designated column with an <code>int</code> value. The <code>updateXXX</code>
      *  methods are used to update column values in the current row or the
      *  insert row. The <code>updateXXX</code> methods do not update the
      *  underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
      *  methods are called to update the database.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateInt( int columnIndex, int x )
         throws SQLException {
         checkIsOpen();
         delegate_.updateInt( columnIndex, x );
     }
 
 
     /***
      *  Updates the designated column with a <code>long</code> value. The <code>updateXXX</code>
      *  methods are used to update column values in the current row or the
      *  insert row. The <code>updateXXX</code> methods do not update the
      *  underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
      *  methods are called to update the database.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateLong( int columnIndex, long x )
         throws SQLException {
         checkIsOpen();
         delegate_.updateLong( columnIndex, x );
     }
 
 
     /***
      *  Updates the designated column with a <code>float</code> value. The
      *  <code>updateXXX</code> methods are used to update column values in the
      *  current row or the insert row. The <code>updateXXX</code> methods do not
      *  update the underlying database; instead the <code>updateRow</code> or
      *  <code>insertRow</code> methods are called to update the database.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateFloat( int columnIndex, float x )
         throws SQLException {
         checkIsOpen();
         delegate_.updateFloat( columnIndex, x );
     }
 
 
     /***
      *  Updates the designated column with a <code>double</code> value. The
      *  <code>updateXXX</code> methods are used to update column values in the
      *  current row or the insert row. The <code>updateXXX</code> methods do not
      *  update the underlying database; instead the <code>updateRow</code> or
      *  <code>insertRow</code> methods are called to update the database.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateDouble( int columnIndex, double x )
         throws SQLException {
         checkIsOpen();
         delegate_.updateDouble( columnIndex, x );
     }
 
 
     /***
      *  Updates the designated column with a <code>java.math.BigDecimal</code>
      *  value. The <code>updateXXX</code> methods are used to update column
      *  values in the current row or the insert row. The <code>updateXXX</code>
      *  methods do not update the underlying database; instead the <code>updateRow</code>
      *  or <code>insertRow</code> methods are called to update the database.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateBigDecimal( int columnIndex, BigDecimal x )
         throws SQLException {
         checkIsOpen();
         delegate_.updateBigDecimal( columnIndex, x );
     }
 
 
     /***
      *  Updates the designated column with a <code>String</code> value. The
      *  <code>updateXXX</code> methods are used to update column values in the
      *  current row or the insert row. The <code>updateXXX</code> methods do not
      *  update the underlying database; instead the <code>updateRow</code> or
      *  <code>insertRow</code> methods are called to update the database.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateString( int columnIndex, String x )
         throws SQLException {
         checkIsOpen();
         delegate_.updateString( columnIndex, x );
     }
 
 
     /***
      *  Updates the designated column with a <code>byte</code> array value. The
      *  <code>updateXXX</code> methods are used to update column values in the
      *  current row or the insert row. The <code>updateXXX</code> methods do not
      *  update the underlying database; instead the <code>updateRow</code> or
      *  <code>insertRow</code> methods are called to update the database.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateBytes( int columnIndex, byte x[] )
         throws SQLException {
         checkIsOpen();
         delegate_.updateBytes( columnIndex, x );
     }
 
 
     /***
      *  Updates the designated column with a <code>java.sql.Date</code> value.
      *  The <code>updateXXX</code> methods are used to update column values in
      *  the current row or the insert row. The <code>updateXXX</code> methods do
      *  not update the underlying database; instead the <code>updateRow</code>
      *  or <code>insertRow</code> methods are called to update the database.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateDate( int columnIndex, java.sql.Date x )
         throws SQLException {
         checkIsOpen();
         delegate_.updateDate( columnIndex, x );
     }
 
 
     /***
      *  Updates the designated column with a <code>java.sql.Time</code> value.
      *  The <code>updateXXX</code> methods are used to update column values in
      *  the current row or the insert row. The <code>updateXXX</code> methods do
      *  not update the underlying database; instead the <code>updateRow</code>
      *  or <code>insertRow</code> methods are called to update the database.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateTime( int columnIndex, java.sql.Time x )
         throws SQLException {
         checkIsOpen();
         delegate_.updateTime( columnIndex, x );
     }
 
 
     /***
      *  Updates the designated column with a <code>java.sql.Timestamp</code>
      *  value. The <code>updateXXX</code> methods are used to update column
      *  values in the current row or the insert row. The <code>updateXXX</code>
      *  methods do not update the underlying database; instead the <code>updateRow</code>
      *  or <code>insertRow</code> methods are called to update the database.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateTimestamp( int columnIndex, java.sql.Timestamp x )
         throws SQLException {
         checkIsOpen();
         delegate_.updateTimestamp( columnIndex, x );
     }
 
 
     /***
      *  Updates the designated column with an ascii stream value. The <code>updateXXX</code>
      *  methods are used to update column values in the current row or the
      *  insert row. The <code>updateXXX</code> methods do not update the
      *  underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
      *  methods are called to update the database.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @param  x the new column value
      * @param  length the length of the stream
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateAsciiStream( int columnIndex,
             java.io.InputStream x,
             int length )
         throws SQLException {
         checkIsOpen();
         delegate_.updateAsciiStream( columnIndex, x, length );
     }
 
 
     /***
      *  Updates the designated column with a binary stream value. The <code>updateXXX</code>
      *  methods are used to update column values in the current row or the
      *  insert row. The <code>updateXXX</code> methods do not update the
      *  underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
      *  methods are called to update the database.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @param  x the new column value
      * @param  length the length of the stream
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateBinaryStream( int columnIndex,
             java.io.InputStream x,
             int length )
         throws SQLException {
         checkIsOpen();
         delegate_.updateBinaryStream( columnIndex, x, length );
     }
 
 
     /***
      *  Updates the designated column with a character stream value. The <code>updateXXX</code>
      *  methods are used to update column values in the current row or the
      *  insert row. The <code>updateXXX</code> methods do not update the
      *  underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
      *  methods are called to update the database.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @param  x the new column value
      * @param  length the length of the stream
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateCharacterStream( int columnIndex,
             java.io.Reader x,
             int length )
         throws SQLException {
         checkIsOpen();
         delegate_.updateCharacterStream( columnIndex, x, length );
     }
 
 
     /***
      *  Updates the designated column with an <code>Object</code> value. The
      *  <code>updateXXX</code> methods are used to update column values in the
      *  current row or the insert row. The <code>updateXXX</code> methods do not
      *  update the underlying database; instead the <code>updateRow</code> or
      *  <code>insertRow</code> methods are called to update the database.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @param  x the new column value
      * @param  scale for <code>java.sql.Types.DECIMA</code> or <code>java.sql.Types.NUMERIC</code>
      *      types, this is the number of digits after the decimal point. For all
      *      other types this value will be ignored.
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateObject( int columnIndex, Object x, int scale )
         throws SQLException {
         checkIsOpen();
         delegate_.updateObject( columnIndex, x, scale );
     }
 
 
     /***
      *  Updates the designated column with an <code>Object</code> value. The
      *  <code>updateXXX</code> methods are used to update column values in the
      *  current row or the insert row. The <code>updateXXX</code> methods do not
      *  update the underlying database; instead the <code>updateRow</code> or
      *  <code>insertRow</code> methods are called to update the database.
      *
      * @param  columnIndex the first column is 1, the second is 2, ...
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateObject( int columnIndex, Object x )
         throws SQLException {
         checkIsOpen();
         delegate_.updateObject( columnIndex, x );
     }
 
 
     /***
      *  Updates the designated column with a <code>null</code> value. The <code>updateXXX</code>
      *  methods are used to update column values in the current row or the
      *  insert row. The <code>updateXXX</code> methods do not update the
      *  underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
      *  methods are called to update the database.
      *
      * @param  columnName the name of the column
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateNull( String columnName )
         throws SQLException {
         checkIsOpen();
         delegate_.updateNull( columnName );
     }
 
 
     /***
      *  Updates the designated column with a <code>boolean</code> value. The
      *  <code>updateXXX</code> methods are used to update column values in the
      *  current row or the insert row. The <code>updateXXX</code> methods do not
      *  update the underlying database; instead the <code>updateRow</code> or
      *  <code>insertRow</code> methods are called to update the database.
      *
      * @param  columnName the name of the column
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateBoolean( String columnName, boolean x )
         throws SQLException {
         checkIsOpen();
         delegate_.updateBoolean( columnName, x );
     }
 
 
     /***
      *  Updates the designated column with a <code>byte</code> value. The <code>updateXXX</code>
      *  methods are used to update column values in the current row or the
      *  insert row. The <code>updateXXX</code> methods do not update the
      *  underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
      *  methods are called to update the database.
      *
      * @param  columnName the name of the column
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateByte( String columnName, byte x )
         throws SQLException {
         checkIsOpen();
         delegate_.updateByte( columnName, x );
     }
 
 
     /***
      *  Updates the designated column with a <code>short</code> value. The
      *  <code>updateXXX</code> methods are used to update column values in the
      *  current row or the insert row. The <code>updateXXX</code> methods do not
      *  update the underlying database; instead the <code>updateRow</code> or
      *  <code>insertRow</code> methods are called to update the database.
      *
      * @param  columnName the name of the column
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateShort( String columnName, short x )
         throws SQLException {
         checkIsOpen();
         delegate_.updateShort( columnName, x );
     }
 
 
     /***
      *  Updates the designated column with an <code>int</code> value. The <code>updateXXX</code>
      *  methods are used to update column values in the current row or the
      *  insert row. The <code>updateXXX</code> methods do not update the
      *  underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
      *  methods are called to update the database.
      *
      * @param  columnName the name of the column
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateInt( String columnName, int x )
         throws SQLException {
         checkIsOpen();
         delegate_.updateInt( columnName, x );
     }
 
 
     /***
      *  Updates the designated column with a <code>long</code> value. The <code>updateXXX</code>
      *  methods are used to update column values in the current row or the
      *  insert row. The <code>updateXXX</code> methods do not update the
      *  underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
      *  methods are called to update the database.
      *
      * @param  columnName the name of the column
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateLong( String columnName, long x )
         throws SQLException {
         checkIsOpen();
         delegate_.updateLong( columnName, x );
     }
 
 
     /***
      *  Updates the designated column with a <code>float </code> value. The
      *  <code>updateXXX</code> methods are used to update column values in the
      *  current row or the insert row. The <code>updateXXX</code> methods do not
      *  update the underlying database; instead the <code>updateRow</code> or
      *  <code>insertRow</code> methods are called to update the database.
      *
      * @param  columnName the name of the column
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateFloat( String columnName, float x )
         throws SQLException {
         checkIsOpen();
         delegate_.updateFloat( columnName, x );
     }
 
 
     /***
      *  Updates the designated column with a <code>double</code> value. The
      *  <code>updateXXX</code> methods are used to update column values in the
      *  current row or the insert row. The <code>updateXXX</code> methods do not
      *  update the underlying database; instead the <code>updateRow</code> or
      *  <code>insertRow</code> methods are called to update the database.
      *
      * @param  columnName the name of the column
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateDouble( String columnName, double x )
         throws SQLException {
         checkIsOpen();
         delegate_.updateDouble( columnName, x );
     }
 
 
     /***
      *  Updates the designated column with a <code>java.sql.BigDecimal</code>
      *  value. The <code>updateXXX</code> methods are used to update column
      *  values in the current row or the insert row. The <code>updateXXX</code>
      *  methods do not update the underlying database; instead the <code>updateRow</code>
      *  or <code>insertRow</code> methods are called to update the database.
      *
      * @param  columnName the name of the column
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateBigDecimal( String columnName, BigDecimal x )
         throws SQLException {
         checkIsOpen();
         delegate_.updateBigDecimal( columnName, x );
     }
 
 
     /***
      *  Updates the designated column with a <code>String</code> value. The
      *  <code>updateXXX</code> methods are used to update column values in the
      *  current row or the insert row. The <code>updateXXX</code> methods do not
      *  update the underlying database; instead the <code>updateRow</code> or
      *  <code>insertRow</code> methods are called to update the database.
      *
      * @param  columnName the name of the column
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateString( String columnName, String x )
         throws SQLException {
         checkIsOpen();
         delegate_.updateString( columnName, x );
     }
 
 
     /***
      *  Updates the designated column with a <code>boolean</code> value. The
      *  <code>updateXXX</code> methods are used to update column values in the
      *  current row or the insert row. The <code>updateXXX</code> methods do not
      *  update the underlying database; instead the <code>updateRow</code> or
      *  <code>insertRow</code> methods are called to update the database. JDBC
      *  2.0 Updates a column with a byte array value. The <code>updateXXX</code>
      *  methods are used to update column values in the current row, or the
      *  insert row. The <code>updateXXX</code> methods do not update the
      *  underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
      *  methods are called to update the database.
      *
      * @param  columnName the name of the column
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateBytes( String columnName, byte x[] )
         throws SQLException {
         checkIsOpen();
         delegate_.updateBytes( columnName, x );
     }
 
 
     /***
      *  Updates the designated column with a <code>java.sql.Date</code> value.
      *  The <code>updateXXX</code> methods are used to update column values in
      *  the current row or the insert row. The <code>updateXXX</code> methods do
      *  not update the underlying database; instead the <code>updateRow</code>
      *  or <code>insertRow</code> methods are called to update the database.
      *
      * @param  columnName the name of the column
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateDate( String columnName, java.sql.Date x )
         throws SQLException {
         checkIsOpen();
         delegate_.updateDate( columnName, x );
     }
 
 
     /***
      *  Updates the designated column with a <code>java.sql.Time</code> value.
      *  The <code>updateXXX</code> methods are used to update column values in
      *  the current row or the insert row. The <code>updateXXX</code> methods do
      *  not update the underlying database; instead the <code>updateRow</code>
      *  or <code>insertRow</code> methods are called to update the database.
      *
      * @param  columnName the name of the column
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateTime( String columnName, java.sql.Time x )
         throws SQLException {
         checkIsOpen();
         delegate_.updateTime( columnName, x );
     }
 
 
     /***
      *  Updates the designated column with a <code>java.sql.Timestamp</code>
      *  value. The <code>updateXXX</code> methods are used to update column
      *  values in the current row or the insert row. The <code>updateXXX</code>
      *  methods do not update the underlying database; instead the <code>updateRow</code>
      *  or <code>insertRow</code> methods are called to update the database.
      *
      * @param  columnName the name of the column
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateTimestamp( String columnName, java.sql.Timestamp x )
         throws SQLException {
         checkIsOpen();
         delegate_.updateTimestamp( columnName, x );
     }
 
 
     /***
      *  Updates the designated column with an ascii stream value. The <code>updateXXX</code>
      *  methods are used to update column values in the current row or the
      *  insert row. The <code>updateXXX</code> methods do not update the
      *  underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
      *  methods are called to update the database.
      *
      * @param  columnName the name of the column
      * @param  x the new column value
      * @param  length the length of the stream
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateAsciiStream( String columnName,
             java.io.InputStream x,
             int length )
         throws SQLException {
         checkIsOpen();
         delegate_.updateAsciiStream( columnName, x, length );
     }
 
 
     /***
      *  Updates the designated column with a binary stream value. The <code>updateXXX</code>
      *  methods are used to update column values in the current row or the
      *  insert row. The <code>updateXXX</code> methods do not update the
      *  underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
      *  methods are called to update the database.
      *
      * @param  columnName the name of the column
      * @param  x the new column value
      * @param  length the length of the stream
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateBinaryStream( String columnName,
             java.io.InputStream x,
             int length )
         throws SQLException {
         checkIsOpen();
         delegate_.updateBinaryStream( columnName, x, length );
     }
 
 
     /***
      *  Updates the designated column with a character stream value. The <code>updateXXX</code>
      *  methods are used to update column values in the current row or the
      *  insert row. The <code>updateXXX</code> methods do not update the
      *  underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
      *  methods are called to update the database.
      *
      * @param  columnName the name of the column
      * @param  reader the new column value
      * @param  length the length of the stream
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateCharacterStream( String columnName,
             java.io.Reader reader,
             int length )
         throws SQLException {
         checkIsOpen();
         delegate_.updateCharacterStream( columnName, reader, length );
     }
 
 
     /***
      *  Updates the designated column with an <code>Object</code> value. The
      *  <code>updateXXX</code> methods are used to update column values in the
      *  current row or the insert row. The <code>updateXXX</code> methods do not
      *  update the underlying database; instead the <code>updateRow</code> or
      *  <code>insertRow</code> methods are called to update the database.
      *
      * @param  columnName the name of the column
      * @param  x the new column value
      * @param  scale for <code>java.sql.Types.DECIMA</code> or <code>java.sql.Types.NUMERIC</code>
      *      types, this is the number of digits after the decimal point. For all
      *      other types this value will be ignored.
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateObject( String columnName, Object x, int scale )
         throws SQLException {
         checkIsOpen();
         delegate_.updateObject( columnName, x, scale );
     }
 
 
     /***
      *  Updates the designated column with an <code>Object</code> value. The
      *  <code>updateXXX</code> methods are used to update column values in the
      *  current row or the insert row. The <code>updateXXX</code> methods do not
      *  update the underlying database; instead the <code>updateRow</code> or
      *  <code>insertRow</code> methods are called to update the database.
      *
      * @param  columnName the name of the column
      * @param  x the new column value
      * @exception  SQLException if a database access error occurs
      * @since  1.2
      */
     public final void updateObject( String columnName, Object x )
         throws SQLException {
         checkIsOpen();
         delegate_.updateObject( columnName, x );
     }
 
 
     /***
      *  Inserts the contents of the insert row into this <code>ResultSet</code>
      *  objaect and into the database. The cursor must be on the insert row when
      *  this method is called.
      *
      * @exception  SQLException if a database access error occurs, if this
      *      method is called when the cursor is not on the insert row, or if not
      *      all of non-nullable columns in the insert row have been given a
      *      value
      * @since  1.2
      */
     public final void insertRow()
         throws SQLException {
         checkIsOpen();
         delegate_.insertRow();
     }
 
 
     /***
      *  Updates the underlying database with the new contents of the current row
      *  of this <code>ResultSet</code> object. This method cannot be called when
      *  the cursor is on the insert row.
      *
      * @exception  SQLException if a database access error occurs or if this
      *      method is called when the cursor is on the insert row
      * @since  1.2
      */
     public final void updateRow()
         throws SQLException {
         checkIsOpen();
         delegate_.updateRow();
     }
 
 
     /***
      *  Deletes the current row from this <code>ResultSet</code> object and from
      *  the underlying database. This method cannot be called when the cursor is
      *  on the insert row.
      *
      * @exception  SQLException if a database access error occurs or if this
      *      method is called when the cursor is on the insert row
      * @since  1.2
      */
     public final void deleteRow()
         throws SQLException {
         checkIsOpen();
         delegate_.deleteRow();
     }
 
 
     /***
      *  Refreshes the current row with its most recent value in the database.
      *  This method cannot be called when the cursor is on the insert row. <P>
      *
      *  The <code>refreshRow</code> method provides a way for an application to
      *  explicitly tell the JDBC driver to refetch a row(s) from the database.
      *  An application may want to call <code>refreshRow</code> when caching or
      *  prefetching is being done by the JDBC driver to fetch the latest value
      *  of a row from the database. The JDBC driver may actually refresh
      *  multiple rows at once if the fetch size is greater than one. <P>
      *
      *  All values are refetched subject to the transaction isolation level and
      *  cursor sensitivity. If <code>refreshRow</code> is called after calling
      *  an <code>updateXXX</code> method, but before calling the method <code>updateRow</code>
      *  , then the updates made to the row are lost. Calling the method <code>refreshRow</code>
      *  frequently will likely slow performance.
      *
      * @exception  SQLException if a database access error occurs or if this
      *      method is called when the cursor is on the insert row
      * @since  1.2
      */
     public final void refreshRow()
         throws SQLException {
         checkIsOpen();
         delegate_.refreshRow();
     }
 
 
     /***
      *  Cancels the updates made to the current row in this <code>ResultSet</code>
      *  object. This method may be called after calling an <code>updateXXX</code>
      *  method(s) and before calling the method <code>updateRow</code> to roll
      *  back the updates made to a row. If no updates have been made or <code>updateRow</code>
      *  has already been called, this method has no effect.
      *
      * @exception  SQLException if a database access error occurs or if this
      *      method is called when the cursor is on the insert row
      * @since  1.2
      */
     public final void cancelRowUpdates()
         throws SQLException {
         checkIsOpen();
         delegate_.cancelRowUpdates();
     }
 
 
     /***
      *  Moves the cursor to the insert row. The current cursor position is
      *  remembered while the cursor is positioned on the insert row. The insert
      *  row is a special row associated with an updatable result set. It is
      *  essentially a buffer where a new row may be constructed by calling the
      *  <code>updateXXX</code> methods prior to inserting the row into the
      *  result set. Only the <code>updateXXX</code>, <code>getXXX</code>, and
      *  <code>insertRow</code> methods may be called when the cursor is on the
      *  insert row. All of the columns in a result set must be given a value
      *  each time this method is called before calling <code>insertRow</code>.
      *  An <code>updateXXX</code> method must be called before a <code>getXXX</code>
      *  method can be called on a column value.
      *
      * @exception  SQLException if a database access error occurs or the result
      *      set is not updatable
      * @since  1.2
      */
     public final void moveToInsertRow()
         throws SQLException {
         checkIsOpen();
         delegate_.moveToInsertRow();
     }
 
 
     /***
      *  Moves the cursor to the remembered cursor position, usually the current
      *  row. This method has no effect if the cursor is not on the insert row.
      *
      * @exception  SQLException if a database access error occurs or the result
      *      set is not updatable
      * @since  1.2
      */
     public final void moveToCurrentRow()
         throws SQLException {
         checkIsOpen();
         delegate_.moveToCurrentRow();
     }
 
 
     private void checkIsOpen()
         throws SQLException {
         if( isOpen_ == false ) {
             throw new SQLException( "ResultSet is closed" );
         }
     }
 
 
     /***
      * Retrieves the value of the designated column in the current row
      * of this <code>ResultSet</code> object as a <code>java.net.URL</code>
      * object in the Java programming language.
      *
      * @param columnIndex the index of the column 1 is the first, 2 is the second,...
      * @return the column value as a <code>java.net.URL</code> object;
      * if the value is SQL <code>NULL</code>,
      * the value returned is <code>null</code> in the Java programming language
      * @exception SQLException if a database access error occurs,
      *            or if a URL is malformed
      * @since 1.4
      */
     public java.net.URL getURL(int columnIndex) throws SQLException {
         checkIsOpen();
         return delegate_.getURL(columnIndex);
     }
 
 
     /***
      * Retrieves the value of the designated column in the current row
      * of this <code>ResultSet</code> object as a <code>java.net.URL</code>
      * object in the Java programming language.
      *
      * @param columnName the SQL name of the column
      * @return the column value as a <code>java.net.URL</code> object;
      * if the value is SQL <code>NULL</code>,
      * the value returned is <code>null</code> in the Java programming language
      * @exception SQLException if a database access error occurs
      *            or if a URL is malformed
      * @since 1.4
      */
     public java.net.URL getURL(String columnName) throws SQLException {
         checkIsOpen();
         return delegate_.getURL(columnName);
     }
 
 
     /***
      * Updates the designated column with a <code>java.sql.Ref</code> value.
      * The updater methods are used to update column values in the
      * current row or the insert row.  The updater methods do not
      * update the underlying database; instead the <code>updateRow</code> or
      * <code>insertRow</code> methods are called to update the database.
      *
      * @param columnIndex the first column is 1, the second is 2, ...
      * @param x the new column value
      * @exception SQLException if a database access error occurs
      * @since 1.4
      */
     public void updateRef(int columnIndex, java.sql.Ref x) throws SQLException {
         checkIsOpen();
         delegate_.updateRef(columnIndex, x);
     }
 
 
     /***
      * Updates the designated column with a <code>java.sql.Ref</code> value.
      * The updater methods are used to update column values in the
      * current row or the insert row.  The updater methods do not
      * update the underlying database; instead the <code>updateRow</code> or
      * <code>insertRow</code> methods are called to update the database.
      *
      * @param columnName the name of the column
      * @param x the new column value
      * @exception SQLException if a database access error occurs
      * @since 1.4
      */
     public void updateRef(String columnName, java.sql.Ref x) throws SQLException {
         checkIsOpen();
         delegate_.updateRef(columnName, x);
     }
 
 
     /***
      * Updates the designated column with a <code>java.sql.Blob</code> value.
      * The updater methods are used to update column values in the
      * current row or the insert row.  The updater methods do not
      * update the underlying database; instead the <code>updateRow</code> or
      * <code>insertRow</code> methods are called to update the database.
      *
      * @param columnIndex the first column is 1, the second is 2, ...
      * @param x the new column value
      * @exception SQLException if a database access error occurs
      * @since 1.4
      */
     public void updateBlob(int columnIndex, java.sql.Blob x) throws SQLException {
         checkIsOpen();
         delegate_.updateBlob(columnIndex, x);
     }
 
 
     /***
      * Updates the designated column with a <code>java.sql.Blob</code> value.
      * The updater methods are used to update column values in the
      * current row or the insert row.  The updater methods do not
      * update the underlying database; instead the <code>updateRow</code> or
      * <code>insertRow</code> methods are called to update the database.
      *
      * @param columnName the name of the column
      * @param x the new column value
      * @exception SQLException if a database access error occurs
      * @since 1.4
      */
     public void updateBlob(String columnName, java.sql.Blob x) throws SQLException {
         checkIsOpen();
         delegate_.updateBlob(columnName, x);
     }
 
 
     /***
      * Updates the designated column with a <code>java.sql.Clob</code> value.
      * The updater methods are used to update column values in the
      * current row or the insert row.  The updater methods do not
      * update the underlying database; instead the <code>updateRow</code> or
      * <code>insertRow</code> methods are called to update the database.
      *
      * @param columnIndex the first column is 1, the second is 2, ...
      * @param x the new column value
      * @exception SQLException if a database access error occurs
      * @since 1.4
      */
     public void updateClob(int columnIndex, java.sql.Clob x) throws SQLException {
         checkIsOpen();
         delegate_.updateClob(columnIndex, x);
     }
 
 
     /***
      * Updates the designated column with a <code>java.sql.Clob</code> value.
      * The updater methods are used to update column values in the
      * current row or the insert row.  The updater methods do not
      * update the underlying database; instead the <code>updateRow</code> or
      * <code>insertRow</code> methods are called to update the database.
      *
      * @param columnName the name of the column
      * @param x the new column value
      * @exception SQLException if a database access error occurs
      * @since 1.4
      */
     public void updateClob(String columnName, java.sql.Clob x) throws SQLException {
         checkIsOpen();
         delegate_.updateClob(columnName, x);
     }
 
 
     /***
      * Updates the designated column with a <code>java.sql.Array</code> value.
      * The updater methods are used to update column values in the
      * current row or the insert row.  The updater methods do not
      * update the underlying database; instead the <code>updateRow</code> or
      * <code>insertRow</code> methods are called to update the database.
      *
      * @param columnIndex the first column is 1, the second is 2, ...
      * @param x the new column value
      * @exception SQLException if a database access error occurs
      * @since 1.4
      */
     public void updateArray(int columnIndex, java.sql.Array x) throws SQLException {
         checkIsOpen();
         delegate_.updateArray( columnIndex, x );
     }
 
 
     /***
      * Updates the designated column with a <code>java.sql.Array</code> value.
      * The updater methods are used to update column values in the
      * current row or the insert row.  The updater methods do not
      * update the underlying database; instead the <code>updateRow</code> or
      * <code>insertRow</code> methods are called to update the database.
      *
      * @param columnName the name of the column
      * @param x the new column value
      * @exception SQLException if a database access error occurs
      * @since 1.4
      */
     public void updateArray(String columnName, java.sql.Array x) throws SQLException {
         checkIsOpen();
         delegate_.updateArray(columnName, x);
     }
 }