View Javadoc

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