gsbase - 2.0.1

Clover coverage report - gsbase - 2.0.1

Coverage timestamp: Sat Jan 1 2005 12:30:02 EST

FRAMES NO FRAMES

file stats:	LOC:	2,916		Methods:	143
	NCLOC:	737		Classes:	1

Source file

Conditionals

Statements

Methods

TOTAL

ResultSetWrapper.java

100%

100%

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	170	public ResultSetWrapper( final ResultSet resultSet ) {
162	170	if( resultSet == null ) {
163	1	throw new NullPointerException( "resultSet" );
164		}
165	169	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	2	public final void setFetchDirection( int direction )
182		throws SQLException {
183	2	checkIsOpen();
184	1	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	2	public final void setFetchSize( int rows )
203		throws SQLException {
204	2	checkIsOpen();
205	1	delegate_.setFetchSize( rows );
206		}
207
208
209		/**
210		* Return the wrapped object
211		*
212		* @return The wrapped object
213		*/
214	26	public final ResultSet getDelegate() {
215	26	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	28	public final boolean isClosed() {
225	28	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	2	public final String getString( int columnIndex )
243		throws SQLException {
244	2	checkIsOpen();
245	1	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	2	public final boolean getBoolean( int columnIndex )
260		throws SQLException {
261	2	checkIsOpen();
262	1	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	2	public final byte getByte( int columnIndex )
277		throws SQLException {
278	2	checkIsOpen();
279	1	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	2	public final short getShort( int columnIndex )
294		throws SQLException {
295	2	checkIsOpen();
296	1	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	2	public final int getInt( int columnIndex )
311		throws SQLException {
312	2	checkIsOpen();
313	1	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	2	public final long getLong( int columnIndex )
328		throws SQLException {
329	2	checkIsOpen();
330	1	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	2	public final float getFloat( int columnIndex )
345		throws SQLException {
346	2	checkIsOpen();
347	1	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	2	public final double getDouble( int columnIndex )
362		throws SQLException {
363	2	checkIsOpen();
364	1	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	2	public final BigDecimal getBigDecimal( int columnIndex, int scale )
381		throws SQLException {
382	2	checkIsOpen();
383	1	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	2	public final byte[] getBytes( int columnIndex )
399		throws SQLException {
400	2	checkIsOpen();
401	1	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	2	public final java.sql.Date getDate( int columnIndex )
416		throws SQLException {
417	2	checkIsOpen();
418	1	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	2	public final java.sql.Time getTime( int columnIndex )
433		throws SQLException {
434	2	checkIsOpen();
435	1	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	2	public final java.sql.Timestamp getTimestamp( int columnIndex )
450		throws SQLException {
451	2	checkIsOpen();
452	1	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	2	public final java.io.InputStream getAsciiStream( int columnIndex )
477		throws SQLException {
478	2	checkIsOpen();
479	1	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	2	public final java.io.InputStream getUnicodeStream( int columnIndex )
507		throws SQLException {
508	2	checkIsOpen();
509	1	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	2	public final java.io.InputStream getBinaryStream( int columnIndex )
533		throws SQLException {
534	2	checkIsOpen();
535	1	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	2	public final String getString( String columnName )
554		throws SQLException {
555	2	checkIsOpen();
556	1	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	2	public final boolean getBoolean( String columnName )
571		throws SQLException {
572	2	checkIsOpen();
573	1	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	2	public final byte getByte( String columnName )
588		throws SQLException {
589	2	checkIsOpen();
590	1	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	2	public final short getShort( String columnName )
605		throws SQLException {
606	2	checkIsOpen();
607	1	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	2	public final int getInt( String columnName )
622		throws SQLException {
623	2	checkIsOpen();
624	1	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	2	public final long getLong( String columnName )
639		throws SQLException {
640	2	checkIsOpen();
641	1	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	2	public final float getFloat( String columnName )
656		throws SQLException {
657	2	checkIsOpen();
658	1	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	2	public final double getDouble( String columnName )
673		throws SQLException {
674	2	checkIsOpen();
675	1	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	2	public final BigDecimal getBigDecimal( String columnName, int scale )
692		throws SQLException {
693	2	checkIsOpen();
694	1	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	2	public final byte[] getBytes( String columnName )
710		throws SQLException {
711	2	checkIsOpen();
712	1	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	2	public final java.sql.Date getDate( String columnName )
727		throws SQLException {
728	2	checkIsOpen();
729	1	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	2	public final java.sql.Time getTime( String columnName )
744		throws SQLException {
745	2	checkIsOpen();
746	1	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	2	public final java.sql.Timestamp getTimestamp( String columnName )
761		throws SQLException {
762	2	checkIsOpen();
763	1	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	2	public final java.io.InputStream getAsciiStream( String columnName )
788		throws SQLException {
789	2	checkIsOpen();
790	1	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	2	public final java.io.InputStream getUnicodeStream( String columnName )
817		throws SQLException {
818	2	checkIsOpen();
819	1	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	2	public final java.io.InputStream getBinaryStream( String columnName )
843		throws SQLException {
844	2	checkIsOpen();
845	1	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	2	public final SQLWarning getWarnings()
871		throws SQLException {
872	2	checkIsOpen();
873	1	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	2	public final String getCursorName()
901		throws SQLException {
902	2	checkIsOpen();
903	1	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	2	public final ResultSetMetaData getMetaData()
915		throws SQLException {
916	2	checkIsOpen();
917	1	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	2	public final Object getObject( int columnIndex )
945		throws SQLException {
946	2	checkIsOpen();
947	1	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	2	public final Object getObject( String columnName )
975		throws SQLException {
976	2	checkIsOpen();
977	1	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	2	public final java.io.Reader getCharacterStream( int columnIndex )
993		throws SQLException {
994	2	checkIsOpen();
995	1	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	2	public final java.io.Reader getCharacterStream( String columnName )
1011		throws SQLException {
1012	2	checkIsOpen();
1013	1	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	2	public final BigDecimal getBigDecimal( int columnIndex )
1030		throws SQLException {
1031	2	checkIsOpen();
1032	1	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	2	public final BigDecimal getBigDecimal( String columnName )
1049		throws SQLException {
1050	2	checkIsOpen();
1051	1	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	2	public final boolean isBeforeFirst()
1069		throws SQLException {
1070	2	checkIsOpen();
1071	1	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	2	public final boolean isAfterLast()
1086		throws SQLException {
1087	2	checkIsOpen();
1088	1	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	2	public final boolean isFirst()
1102		throws SQLException {
1103	2	checkIsOpen();
1104	1	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	2	public final boolean isLast()
1120		throws SQLException {
1121	2	checkIsOpen();
1122	1	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	2	public final int getRow()
1136		throws SQLException {
1137	2	checkIsOpen();
1138	1	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	2	public final int getFetchDirection()
1151		throws SQLException {
1152	2	checkIsOpen();
1153	1	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	2	public final int getFetchSize()
1165		throws SQLException {
1166	2	checkIsOpen();
1167	1	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	2	public final int getType()
1182		throws SQLException {
1183	2	checkIsOpen();
1184	1	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	2	public final int getConcurrency()
1199		throws SQLException {
1200	2	checkIsOpen();
1201	1	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	2	public final Statement getStatement()
1218		throws SQLException {
1219	2	checkIsOpen();
1220	1	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	2	public final Object getObject( int i, java.util.Map map )
1240		throws SQLException {
1241	2	checkIsOpen();
1242	1	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	2	public final Ref getRef( int i )
1258		throws SQLException {
1259	2	checkIsOpen();
1260	1	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	2	public final Blob getBlob( int i )
1276		throws SQLException {
1277	2	checkIsOpen();
1278	1	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	2	public final Clob getClob( int i )
1294		throws SQLException {
1295	2	checkIsOpen();
1296	1	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	2	public final Array getArray( int i )
1312		throws SQLException {
1313	2	checkIsOpen();
1314	1	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	2	public final Object getObject( String colName, java.util.Map map )
1333		throws SQLException {
1334	2	checkIsOpen();
1335	1	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	2	public final Ref getRef( String colName )
1351		throws SQLException {
1352	2	checkIsOpen();
1353	1	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	2	public final Blob getBlob( String colName )
1369		throws SQLException {
1370	2	checkIsOpen();
1371	1	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	2	public final Clob getClob( String colName )
1387		throws SQLException {
1388	2	checkIsOpen();
1389	1	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	2	public final Array getArray( String colName )
1405		throws SQLException {
1406	2	checkIsOpen();
1407	1	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	2	public final java.sql.Date getDate( int columnIndex, Calendar cal )
1428		throws SQLException {
1429	2	checkIsOpen();
1430	1	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	2	public final java.sql.Date getDate( String columnName, Calendar cal )
1452		throws SQLException {
1453	2	checkIsOpen();
1454	1	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	2	public final java.sql.Time getTime( int columnIndex, Calendar cal )
1475		throws SQLException {
1476	2	checkIsOpen();
1477	1	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	2	public final java.sql.Time getTime( String columnName, Calendar cal )
1498		throws SQLException {
1499	2	checkIsOpen();
1500	1	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	2	public final java.sql.Timestamp getTimestamp( int columnIndex, Calendar cal )
1521		throws SQLException {
1522	2	checkIsOpen();
1523	1	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	2	public final java.sql.Timestamp getTimestamp( String columnName, Calendar cal )
1544		throws SQLException {
1545	2	checkIsOpen();
1546	1	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	2	public final boolean next()
1565		throws SQLException {
1566	2	checkIsOpen();
1567	1	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	170	public final void close()
1585		throws SQLException {
1586	170	if( isOpen_ ) {
1587	169	delegate_.close();
1588	169	delegate_ = null;
1589	169	isOpen_ = false;
1590		}
1591		else {
1592	1	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	2	public final boolean wasNull()
1608		throws SQLException {
1609	2	checkIsOpen();
1610	1	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	2	public final void clearWarnings()
1623		throws SQLException {
1624	2	checkIsOpen();
1625	1	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	2	public final int findColumn( String columnName )
1639		throws SQLException {
1640	2	checkIsOpen();
1641	1	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	2	public final void beforeFirst()
1655		throws SQLException {
1656	2	checkIsOpen();
1657	1	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	2	public final void afterLast()
1671		throws SQLException {
1672	2	checkIsOpen();
1673	1	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	2	public final boolean first()
1687		throws SQLException {
1688	2	checkIsOpen();
1689	1	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	2	public final boolean last()
1703		throws SQLException {
1704	2	checkIsOpen();
1705	1	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	2	public final boolean absolute( int row )
1739		throws SQLException {
1740	2	checkIsOpen();
1741	1	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	2	public final boolean relative( int rows )
1765		throws SQLException {
1766	2	checkIsOpen();
1767	1	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	2	public final boolean previous()
1786		throws SQLException {
1787	2	checkIsOpen();
1788	1	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	2	public final boolean rowUpdated()
1804		throws SQLException {
1805	2	checkIsOpen();
1806	1	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	2	public final boolean rowInserted()
1820		throws SQLException {
1821	2	checkIsOpen();
1822	1	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	2	public final boolean rowDeleted()
1837		throws SQLException {
1838	2	checkIsOpen();
1839	1	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	2	public final void updateNull( int columnIndex )
1855		throws SQLException {
1856	2	checkIsOpen();
1857	1	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	2	public final void updateBoolean( int columnIndex, boolean x )
1874		throws SQLException {
1875	2	checkIsOpen();
1876	1	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	2	public final void updateByte( int columnIndex, byte x )
1893		throws SQLException {
1894	2	checkIsOpen();
1895	1	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	2	public final void updateShort( int columnIndex, short x )
1912		throws SQLException {
1913	2	checkIsOpen();
1914	1	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	2	public final void updateInt( int columnIndex, int x )
1931		throws SQLException {
1932	2	checkIsOpen();
1933	1	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	2	public final void updateLong( int columnIndex, long x )
1950		throws SQLException {
1951	2	checkIsOpen();
1952	1	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	2	public final void updateFloat( int columnIndex, float x )
1969		throws SQLException {
1970	2	checkIsOpen();
1971	1	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	2	public final void updateDouble( int columnIndex, double x )
1988		throws SQLException {
1989	2	checkIsOpen();
1990	1	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	2	public final void updateBigDecimal( int columnIndex, BigDecimal x )
2007		throws SQLException {
2008	2	checkIsOpen();
2009	1	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	2	public final void updateString( int columnIndex, String x )
2026		throws SQLException {
2027	2	checkIsOpen();
2028	1	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	2	public final void updateBytes( int columnIndex, byte x[] )
2045		throws SQLException {
2046	2	checkIsOpen();
2047	1	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	2	public final void updateDate( int columnIndex, java.sql.Date x )
2064		throws SQLException {
2065	2	checkIsOpen();
2066	1	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	2	public final void updateTime( int columnIndex, java.sql.Time x )
2083		throws SQLException {
2084	2	checkIsOpen();
2085	1	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	2	public final void updateTimestamp( int columnIndex, java.sql.Timestamp x )
2102		throws SQLException {
2103	2	checkIsOpen();
2104	1	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	2	public final void updateAsciiStream( int columnIndex,
2122		java.io.InputStream x,
2123		int length )
2124		throws SQLException {
2125	2	checkIsOpen();
2126	1	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	2	public final void updateBinaryStream( int columnIndex,
2144		java.io.InputStream x,
2145		int length )
2146		throws SQLException {
2147	2	checkIsOpen();
2148	1	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	2	public final void updateCharacterStream( int columnIndex,
2166		java.io.Reader x,
2167		int length )
2168		throws SQLException {
2169	2	checkIsOpen();
2170	1	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	2	public final void updateObject( int columnIndex, Object x, int scale )
2190		throws SQLException {
2191	2	checkIsOpen();
2192	1	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	2	public final void updateObject( int columnIndex, Object x )
2209		throws SQLException {
2210	2	checkIsOpen();
2211	1	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	2	public final void updateNull( String columnName )
2227		throws SQLException {
2228	2	checkIsOpen();
2229	1	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	2	public final void updateBoolean( String columnName, boolean x )
2246		throws SQLException {
2247	2	checkIsOpen();
2248	1	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	2	public final void updateByte( String columnName, byte x )
2265		throws SQLException {
2266	2	checkIsOpen();
2267	1	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	2	public final void updateShort( String columnName, short x )
2284		throws SQLException {
2285	2	checkIsOpen();
2286	1	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	2	public final void updateInt( String columnName, int x )
2303		throws SQLException {
2304	2	checkIsOpen();
2305	1	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	2	public final void updateLong( String columnName, long x )
2322		throws SQLException {
2323	2	checkIsOpen();
2324	1	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	2	public final void updateFloat( String columnName, float x )
2341		throws SQLException {
2342	2	checkIsOpen();
2343	1	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	2	public final void updateDouble( String columnName, double x )
2360		throws SQLException {
2361	2	checkIsOpen();
2362	1	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	2	public final void updateBigDecimal( String columnName, BigDecimal x )
2379		throws SQLException {
2380	2	checkIsOpen();
2381	1	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	2	public final void updateString( String columnName, String x )
2398		throws SQLException {
2399	2	checkIsOpen();
2400	1	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	2	public final void updateBytes( String columnName, byte x[] )
2422		throws SQLException {
2423	2	checkIsOpen();
2424	1	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	2	public final void updateDate( String columnName, java.sql.Date x )
2441		throws SQLException {
2442	2	checkIsOpen();
2443	1	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	2	public final void updateTime( String columnName, java.sql.Time x )
2460		throws SQLException {
2461	2	checkIsOpen();
2462	1	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	2	public final void updateTimestamp( String columnName, java.sql.Timestamp x )
2479		throws SQLException {
2480	2	checkIsOpen();
2481	1	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	2	public final void updateAsciiStream( String columnName,
2499		java.io.InputStream x,
2500		int length )
2501		throws SQLException {
2502	2	checkIsOpen();
2503	1	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	2	public final void updateBinaryStream( String columnName,
2521		java.io.InputStream x,
2522		int length )
2523		throws SQLException {
2524	2	checkIsOpen();
2525	1	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	2	public final void updateCharacterStream( String columnName,
2543		java.io.Reader reader,
2544		int length )
2545		throws SQLException {
2546	2	checkIsOpen();
2547	1	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	2	public final void updateObject( String columnName, Object x, int scale )
2567		throws SQLException {
2568	2	checkIsOpen();
2569	1	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	2	public final void updateObject( String columnName, Object x )
2586		throws SQLException {
2587	2	checkIsOpen();
2588	1	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	2	public final void insertRow()
2604		throws SQLException {
2605	2	checkIsOpen();
2606	1	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	2	public final void updateRow()
2620		throws SQLException {
2621	2	checkIsOpen();
2622	1	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	2	public final void deleteRow()
2636		throws SQLException {
2637	2	checkIsOpen();
2638	1	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	2	public final void refreshRow()
2664		throws SQLException {
2665	2	checkIsOpen();
2666	1	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	2	public final void cancelRowUpdates()
2682		throws SQLException {
2683	2	checkIsOpen();
2684	1	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	2	public final void moveToInsertRow()
2706		throws SQLException {
2707	2	checkIsOpen();
2708	1	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	2	public final void moveToCurrentRow()
2721		throws SQLException {
2722	2	checkIsOpen();
2723	1	delegate_.moveToCurrentRow();
2724		}
2725
2726
2727	276	private void checkIsOpen()
2728		throws SQLException {
2729	276	if( isOpen_ == false ) {
2730	138	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	2	public java.net.URL getURL(int columnIndex) throws SQLException {
2749	2	checkIsOpen();
2750	1	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	2	public java.net.URL getURL(String columnName) throws SQLException {
2768	2	checkIsOpen();
2769	1	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	2	public void updateRef(int columnIndex, java.sql.Ref x) throws SQLException {
2786	2	checkIsOpen();
2787	1	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	2	public void updateRef(String columnName, java.sql.Ref x) throws SQLException {
2804	2	checkIsOpen();
2805	1	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	2	public void updateBlob(int columnIndex, java.sql.Blob x) throws SQLException {
2822	2	checkIsOpen();
2823	1	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	2	public void updateBlob(String columnName, java.sql.Blob x) throws SQLException {
2840	2	checkIsOpen();
2841	1	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	2	public void updateClob(int columnIndex, java.sql.Clob x) throws SQLException {
2858	2	checkIsOpen();
2859	1	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	2	public void updateClob(String columnName, java.sql.Clob x) throws SQLException {
2876	2	checkIsOpen();
2877	1	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	2	public void updateArray(int columnIndex, java.sql.Array x) throws SQLException {
2894	2	checkIsOpen();
2895	1	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	2	public void updateArray(String columnName, java.sql.Array x) throws SQLException {
2912	2	checkIsOpen();
2913	1	delegate_.updateArray(columnName, x);
2914		}
2915		}
2916