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