Java > Open Source Codes > org > objectweb > rmijdbc > RJResultSetInterface


1
2 /**
3  * RmiJdbc client/server JDBC Driver
4  * (C) GIE Dyade (Groupe BULL / INRIA Research Center) 1997
5  * (C) ExperLog 1999-2000
6  *
7  * @version 1.0
8  * @author Pierre-Yves Gibello (pierreyves.gibello@experlog.com)
9  */
10
11 package org.objectweb.rmijdbc;
12
13 import java.math.BigDecimal ;
14 import java.util.Calendar ;
15
16 import java.sql.*;
17
18 // TBD: WARNING This file contains a hack for InputStream class...
19 // InputStream is not serializable, of course !
20 // The right way would be to encapsulate InputStream in a RMI remote object
21 // (hope I'll find time to do that)
22
23 /**
24  * <P>A ResultSet provides access to a table of data generated by
25  * executing a Statement. The table rows are retrieved in
26  * sequence. Within a row its column values can be accessed in any
27  * order.
28  *
29  * <P>A ResultSet maintains a cursor pointing to its current row of
30  * data. Initially the cursor is positioned before the first row.
31  * The 'next' method moves the cursor to the next row.
32  *
33  * <P>The getXXX methods retrieve column values for the current
34  * row. You can retrieve values either using the index number of the
35  * column, or by using the name of the column. In general using the
36  * column index will be more efficient. Columns are numbered from 1.
37  *
38  * <P>For maximum portability, ResultSet columns within each row should be
39  * read in left-to-right order and each column should be read only once.
40  *
41  * <P>For the getXXX methods, the JDBC driver attempts to convert the
42  * underlying data to the specified Java type and returns a suitable
43  * Java value. See the JDBC specification for allowable mappings
44  * from SQL types to Java types with the ResultSet.getXXX methods.
45  *
46  * <P>Column names used as input to getXXX methods are case insensitive.
47  * When performing a getXXX using a column name, if several columns have
48  * the same name, then the value of the first matching column will be
49  * returned.
50  *
51  * <P>A ResultSet is automatically closed by the Statement that
52  * generated it when that Statement is closed, re-executed, or is used
53  * to retrieve the next result from a sequence of multiple results.
54  *
55  * <P>The number, types and properties of a ResultSet's columns are
56  * provided by the ResulSetMetaData object returned by the getMetaData
57  * method.
58  *
59  * @see Statement#executeQuery
60  * @see Statement#getResultSet
61  * @see ResultSetMetaData
62  */
63
64 public interface RJResultSetInterface extends java.rmi.Remote {
65
66     /**
67      * A ResultSet is initially positioned before its first row; the
68      * first call to next makes the first row the current row; the
69      * second call makes the second row the current row, etc.
70      *
71      * <P>If an input stream from the previous row is open, it is
72      * implicitly closed. The ResultSet's warning chain is cleared
73      * when a new row is read.
74      *
75      * @return true if the new current row is valid; false if there
76      * are no more rows
77      */
78     boolean next() throws java.rmi.RemoteException , SQLException;
79
80     /**
81      * In some cases, it is desirable to immediately release a
82      * ResultSet's database and JDBC resources instead of waiting for
83      * this to happen when it is automatically closed; the close
84      * method provides this immediate release.
85      *
86      * <P><B>Note:</B> A ResultSet is automatically closed by the
87      * Statement that generated it when that Statement is closed,
88      * re-executed, or is used to retrieve the next result from a
89      * sequence of multiple results. A ResultSet is also automatically
90      * closed when it is garbage collected.
91      */
92     void close() throws java.rmi.RemoteException , SQLException;
93
94     /**
95      * A column may have the value of SQL NULL; wasNull reports whether
96      * the last column read had this special value.
97      * Note that you must first call getXXX on a column to try to read
98      * its value and then call wasNull() to find if the value was
99      * the SQL NULL.
100      *
101      * @return true if last column read was SQL NULL
102      */
103     boolean wasNull() throws java.rmi.RemoteException , SQLException;
104     
105     //======================================================================
106 // Methods for accessing results by column index
107 //======================================================================
108
109     /**
110      * Get the value of a column in the current row as a Java String.
111      *
112      * @param columnIndex the first column is 1, the second is 2, ...
113      * @return the column value; if the value is SQL NULL, the result is null
114      */
115     String getString(int columnIndex) throws java.rmi.RemoteException , SQLException;
116
117     /**
118      * Get the value of a column in the current row as a Java boolean.
119      *
120      * @param columnIndex the first column is 1, the second is 2, ...
121      * @return the column value; if the value is SQL NULL, the result is false
122      */
123     boolean getBoolean(int columnIndex) throws java.rmi.RemoteException , SQLException;
124
125     /**
126      * Get the value of a column in the current row as a Java byte.
127      *
128      * @param columnIndex the first column is 1, the second is 2, ...
129      * @return the column value; if the value is SQL NULL, the result is 0
130      */
131     byte getByte(int columnIndex) throws java.rmi.RemoteException , SQLException;
132
133     /**
134      * Get the value of a column in the current row as a Java short.
135      *
136      * @param columnIndex the first column is 1, the second is 2, ...
137      * @return the column value; if the value is SQL NULL, the result is 0
138      */
139     short getShort(int columnIndex) throws java.rmi.RemoteException , SQLException;
140
141     /**
142      * Get the value of a column in the current row as a Java int.
143      *
144      * @param columnIndex the first column is 1, the second is 2, ...
145      * @return the column value; if the value is SQL NULL, the result is 0
146      */
147     int getInt(int columnIndex) throws java.rmi.RemoteException , SQLException;
148
149     /**
150      * Get the value of a column in the current row as a Java long.
151      *
152      * @param columnIndex the first column is 1, the second is 2, ...
153      * @return the column value; if the value is SQL NULL, the result is 0
154      */
155     long getLong(int columnIndex) throws java.rmi.RemoteException , SQLException;
156
157     /**
158      * Get the value of a column in the current row as a Java float.
159      *
160      * @param columnIndex the first column is 1, the second is 2, ...
161      * @return the column value; if the value is SQL NULL, the result is 0
162      */
163     float getFloat(int columnIndex) throws java.rmi.RemoteException , SQLException;
164
165     /**
166      * Get the value of a column in the current row as a Java double.
167      *
168      * @param columnIndex the first column is 1, the second is 2, ...
169      * @return the column value; if the value is SQL NULL, the result is 0
170      */
171     double getDouble(int columnIndex) throws java.rmi.RemoteException , SQLException;
172
173     /**
174      * Get the value of a column in the current row as a java.lang.BigDecimal object.
175      *
176      * @param columnIndex the first column is 1, the second is 2, ...
177      * @param scale the number of digits to the right of the decimal
178      * @return the column value; if the value is SQL NULL, the result is null
179      */
180     BigDecimal getBigDecimal(int columnIndex, int scale) throws java.rmi.RemoteException , SQLException;
181
182     /**
183      * Get the value of a column in the current row as a Java byte array.
184      * The bytes represent the raw values returned by the driver.
185      *
186      * @param columnIndex the first column is 1, the second is 2, ...
187      * @return the column value; if the value is SQL NULL, the result is null
188      */
189     byte[] getBytes(int columnIndex) throws java.rmi.RemoteException , SQLException;
190
191     /**
192      * Get the value of a column in the current row as a java.sql.Date object.
193      *
194      * @param columnIndex the first column is 1, the second is 2, ...
195      * @return the column value; if the value is SQL NULL, the result is null
196      */
197     java.sql.Date getDate(int columnIndex) throws java.rmi.RemoteException , SQLException;
198
199     /**
200      * Get the value of a column in the current row as a java.sql.Time object.
201      *
202      * @param columnIndex the first column is 1, the second is 2, ...
203      * @return the column value; if the value is SQL NULL, the result is null
204      */
205     java.sql.Time getTime(int columnIndex) throws java.rmi.RemoteException , SQLException;
206
207     /**
208      * Get the value of a column in the current row as a java.sql.Timestamp object.
209      *
210      * @param columnIndex the first column is 1, the second is 2, ...
211      * @return the column value; if the value is SQL NULL, the result is null
212      */
213     java.sql.Timestamp getTimestamp(int columnIndex) throws java.rmi.RemoteException , SQLException;
214
215     /**
216      * A column value can be retrieved as a stream of ASCII characters
217      * and then read in chunks from the stream. This method is particularly
218      * suitable for retrieving large LONGVARCHAR values. The JDBC driver will
219      * do any necessary conversion from the database format into ASCII.
220      *
221      * <P><B>Note:</B> All the data in the returned stream must be
222      * read prior to getting the value of any other column. The next
223      * call to a get method implicitly closes the stream. . Also, a
224      * stream may return 0 for available() whether there is data
225      * available or not.
226      *
227      * @param columnIndex the first column is 1, the second is 2, ...
228      * @return a Java input stream that delivers the database column value
229      * as a stream of one byte ASCII characters. If the value is SQL NULL
230      * then the result is null.
231      */
232 // java.io.InputStream getAsciiStream(int columnIndex)
233 // TBD This is a hack (InputStream not serializable)
234 byte[] getAsciiStream(int columnIndex)
235   throws java.rmi.RemoteException , SQLException;
236
237     /**
238      * A column value can be retrieved as a stream of Unicode characters
239      * and then read in chunks from the stream. This method is particularly
240      * suitable for retrieving large LONGVARCHAR values. The JDBC driver will
241      * do any necessary conversion from the database format into Unicode.
242      *
243      * <P><B>Note:</B> All the data in the returned stream must be
244      * read prior to getting the value of any other column. The next
245      * call to a get method implicitly closes the stream. . Also, a
246      * stream may return 0 for available() whether there is data
247      * available or not.
248      *
249      * @param columnIndex the first column is 1, the second is 2, ...
250      * @return a Java input stream that delivers the database column value
251      * as a stream of two byte Unicode characters. If the value is SQL NULL
252      * then the result is null.
253      */
254 // java.io.InputStream getUnicodeStream(int columnIndex)
255 // TBD This is a hack (InputStream not serializable)
256 byte[] getUnicodeStream(int columnIndex)
257   throws java.rmi.RemoteException , SQLException;
258
259     /**
260      * A column value can be retrieved as a stream of uninterpreted bytes
261      * and then read in chunks from the stream. This method is particularly
262      * suitable for retrieving large LONGVARBINARY values.
263      *
264      * <P><B>Note:</B> All the data in the returned stream must be
265      * read prior to getting the value of any other column. The next
266      * call to a get method implicitly closes the stream. Also, a
267      * stream may return 0 for available() whether there is data
268      * available or not.
269      *
270      * @param columnIndex the first column is 1, the second is 2, ...
271      * @return a Java input stream that delivers the database column value
272      * as a stream of uninterpreted bytes. If the value is SQL NULL
273      * then the result is null.
274      */
275 // java.io.InputStream getBinaryStream(int columnIndex)
276 // TBD This is a hack (InputStream not serializable)
277 byte[] getBinaryStream(int columnIndex)
278   throws java.rmi.RemoteException , SQLException;
279
280
281     //======================================================================
282 // Methods for accessing results by column name
283 //======================================================================
284
285     /**
286      * Get the value of a column in the current row as a Java String.
287      *
288      * @param columnName is the SQL name of the column
289      * @return the column value; if the value is SQL NULL, the result is null
290      */
291     String getString(String columnName) throws java.rmi.RemoteException , SQLException;
292
293     /**
294      * Get the value of a column in the current row as a Java boolean.
295      *
296      * @param columnName is the SQL name of the column
297      * @return the column value; if the value is SQL NULL, the result is false
298      */
299     boolean getBoolean(String columnName) throws java.rmi.RemoteException , SQLException;
300
301     /**
302      * Get the value of a column in the current row as a Java byte.
303      *
304      * @param columnName is the SQL name of the column
305      * @return the column value; if the value is SQL NULL, the result is 0
306      */
307     byte getByte(String columnName) throws java.rmi.RemoteException , SQLException;
308
309     /**
310      * Get the value of a column in the current row as a Java short.
311      *
312      * @param columnName is the SQL name of the column
313      * @return the column value; if the value is SQL NULL, the result is 0
314      */
315     short getShort(String columnName) throws java.rmi.RemoteException , SQLException;
316
317     /**
318      * Get the value of a column in the current row as a Java int.
319      *
320      * @param columnName is the SQL name of the column
321      * @return the column value; if the value is SQL NULL, the result is 0
322      */
323     int getInt(String columnName) throws java.rmi.RemoteException , SQLException;
324
325     /**
326      * Get the value of a column in the current row as a Java long.
327      *
328      * @param columnName is the SQL name of the column
329      * @return the column value; if the value is SQL NULL, the result is 0
330      */
331     long getLong(String columnName) throws java.rmi.RemoteException , SQLException;
332
333     /**
334      * Get the value of a column in the current row as a Java float.
335      *
336      * @param columnName is the SQL name of the column
337      * @return the column value; if the value is SQL NULL, the result is 0
338      */
339     float getFloat(String columnName) throws java.rmi.RemoteException , SQLException;
340
341     /**
342      * Get the value of a column in the current row as a Java double.
343      *
344      * @param columnName is the SQL name of the column
345      * @return the column value; if the value is SQL NULL, the result is 0
346      */
347     double getDouble(String columnName) throws java.rmi.RemoteException , SQLException;
348
349     /**
350      * Get the value of a column in the current row as a java.lang.BigDecimal object.
351      *
352      * @param columnName is the SQL name of the column
353      * @param scale the number of digits to the right of the decimal
354      * @return the column value; if the value is SQL NULL, the result is null
355      */
356     BigDecimal getBigDecimal(String columnName, int scale) throws java.rmi.RemoteException , SQLException;
357
358     /**
359      * Get the value of a column in the current row as a Java byte array.
360      * The bytes represent the raw values returned by the driver.
361      *
362      * @param columnName is the SQL name of the column
363      * @return the column value; if the value is SQL NULL, the result is null
364      */
365     byte[] getBytes(String columnName) throws java.rmi.RemoteException , SQLException;
366
367     /**
368      * Get the value of a column in the current row as a java.sql.Date object.
369      *
370      * @param columnName is the SQL name of the column
371      * @return the column value; if the value is SQL NULL, the result is null
372      */
373     java.sql.Date getDate(String columnName) throws java.rmi.RemoteException , SQLException;
374
375     /**
376      * Get the value of a column in the current row as a java.sql.Time object.
377      *
378      * @param columnName is the SQL name of the column
379      * @return the column value; if the value is SQL NULL, the result is null
380      */
381     java.sql.Time getTime(String columnName) throws java.rmi.RemoteException , SQLException;
382
383     /**
384      * Get the value of a column in the current row as a java.sql.Timestamp object.
385      *
386      * @param columnName is the SQL name of the column
387      * @return the column value; if the value is SQL NULL, the result is null
388      */
389     java.sql.Timestamp getTimestamp(String columnName) throws java.rmi.RemoteException , SQLException;
390
391     /**
392      * A column value can be retrieved as a stream of ASCII characters
393      * and then read in chunks from the stream. This method is particularly
394      * suitable for retrieving large LONGVARCHAR values. The JDBC driver will
395      * do any necessary conversion from the database format into ASCII.
396      *
397      * <P><B>Note:</B> All the data in the returned stream must
398      * be read prior to getting the value of any other column. The
399      * next call to a get method implicitly closes the stream.
400      *
401      * @param columnName is the SQL name of the column
402      * @return a Java input stream that delivers the database column value
403      * as a stream of one byte ASCII characters. If the value is SQL NULL
404      * then the result is null.
405      */
406 // java.io.InputStream getAsciiStream(String columnName)
407 // TBD This is a hack (InputStream not serializable)
408 byte[] getAsciiStream(String columnName)
409   throws java.rmi.RemoteException , SQLException;
410
411     /**
412      * A column value can be retrieved as a stream of Unicode characters
413      * and then read in chunks from the stream. This method is particularly
414      * suitable for retrieving large LONGVARCHAR values. The JDBC driver will
415      * do any necessary conversion from the database format into Unicode.
416      *
417      * <P><B>Note:</B> All the data in the returned stream must
418      * be read prior to getting the value of any other column. The
419      * next call to a get method implicitly closes the stream.
420      *
421      * @param columnName is the SQL name of the column
422      * @return a Java input stream that delivers the database column value
423      * as a stream of two byte Unicode characters. If the value is SQL NULL
424      * then the result is null.
425      */
426 // java.io.InputStream getUnicodeStream(String columnName)
427 // TBD This is a hack (InputStream not serializable)
428 byte[] getUnicodeStream(String columnName) throws java.rmi.RemoteException , SQLException;
429
430     /**
431      * A column value can be retrieved as a stream of uninterpreted bytes
432      * and then read in chunks from the stream. This method is particularly
433      * suitable for retrieving large LONGVARBINARY values.
434      *
435      * <P><B>Note:</B> All the data in the returned stream must
436      * be read prior to getting the value of any other column. The
437      * next call to a get method implicitly closes the stream.
438      *
439      * @param columnName is the SQL name of the column
440      * @return a Java input stream that delivers the database column value
441      * as a stream of uninterpreted bytes. If the value is SQL NULL
442      * then the result is null.
443      */
444 // java.io.InputStream getBinaryStream(String columnName)
445 // TBD This is a hack (InputStream not serializable)
446 byte[] getBinaryStream(String columnName) throws java.rmi.RemoteException , SQLException;
447
448
449     //=====================================================================
450 // Advanced features:
451 //=====================================================================
452
453     /**
454      * <p>The first warning reported by calls on this ResultSet is
455      * returned. Subsequent ResultSet warnings will be chained to this
456      * SQLWarning.
457      *
458      * <P>The warning chain is automatically cleared each time a new
459      * row is read.
460      *
461      * <P><B>Note:</B> This warning chain only covers warnings caused
462      * by ResultSet methods. Any warning caused by statement methods
463      * (such as reading OUT parameters) will be chained on the
464      * Statement object.
465      *
466      * @return the first SQLWarning or null
467      */
468     SQLWarning getWarnings() throws java.rmi.RemoteException , SQLException;
469
470     /**
471      * After this call getWarnings returns null until a new warning is
472      * reported for this ResultSet.
473      */
474     void clearWarnings() throws java.rmi.RemoteException , SQLException;
475
476     /**
477      * Get the name of the SQL cursor used by this ResultSet.
478      *
479      * <P>In SQL, a result table is retrieved through a cursor that is
480      * named. The current row of a result can be updated or deleted
481      * using a positioned update/delete statement that references the
482      * cursor name.
483      *
484      * <P>JDBC supports this SQL feature by providing the name of the
485      * SQL cursor used by a ResultSet. The current row of a ResultSet
486      * is also the current row of this SQL cursor.
487      *
488      * <P><B>Note:</B> If positioned update is not supported a
489      * SQLException is thrown
490      *
491      * @return the ResultSet's SQL cursor name
492      */
493     String getCursorName() throws java.rmi.RemoteException , SQLException;
494
495     /**
496      * The number, types and properties of a ResultSet's columns
497      * are provided by the getMetaData method.
498      *
499      * @return the description of a ResultSet's columns
500      */
501     RJResultSetMetaDataInterface getMetaData() throws java.rmi.RemoteException , SQLException;
502
503     /**
504      * <p>Get the value of a column in the current row as a Java object.
505      *
506      * <p>This method will return the value of the given column as a
507      * Java object. The type of the Java object will be the default
508      * Java Object type corresponding to the column's SQL type,
509      * following the mapping specified in the JDBC spec.
510      *
511      * <p>This method may also be used to read datatabase specific abstract
512      * data types.
513      *
514      * @param columnIndex the first column is 1, the second is 2, ...
515      * @return A java.lang.Object holding the column value.
516      */
517     Object getObject(int columnIndex) throws java.rmi.RemoteException , SQLException;
518
519     /**
520      * <p>Get the value of a column in the current row as a Java object.
521      *
522      * <p>This method will return the value of the given column as a
523      * Java object. The type of the Java object will be the default
524      * Java Object type corresponding to the column's SQL type,
525      * following the mapping specified in the JDBC spec.
526      *
527      * <p>This method may also be used to read datatabase specific abstract
528      * data types.
529      *
530      * @param columnName is the SQL name of the column
531      * @return A java.lang.Object holding the column value.
532      */
533   Object getObject(String columnName)
534   throws java.rmi.RemoteException , SQLException;
535
536     //----------------------------------------------------------------
537
538     /**
539      * Map a Resultset column name to a ResultSet column index.
540      *
541      * @param columnName the name of the column
542      * @return the column index
543      */
544   int findColumn(String columnName)
545   throws java.rmi.RemoteException , SQLException;
546
547       //--------------------------JDBC 2.0-----------------------------------
548
549     //---------------------------------------------------------------------
550 // Getter's and Setter's
551 //---------------------------------------------------------------------
552
553     /**
554      * JDBC 2.0
555      *
556      * <p>Gets the value of a column in the current row as a java.io.Reader.
557      * @param columnIndex the first column is 1, the second is 2, ...
558      */
559     java.io.Reader getCharacterStream(int columnIndex) throws java.rmi.RemoteException , SQLException;
560
561     /**
562      * JDBC 2.0
563      *
564      * <p>Gets the value of a column in the current row as a java.io.Reader.
565      * @param columnName the name of the column
566      * @return the value in the specified column as a <code>java.io.Reader</code>
567      */
568     java.io.Reader getCharacterStream(String columnName) throws java.rmi.RemoteException , SQLException;
569
570     /**
571      * JDBC 2.0
572      *
573      * Gets the value of a column in the current row as a java.math.BigDecimal
574      * object with full precision.
575      *
576      * @param columnIndex the first column is 1, the second is 2, ...
577      * @return the column value (full precision); if the value is SQL NULL,
578      * the result is null
579      * @exception SQLException if a database access error occurs
580      */
581     BigDecimal getBigDecimal(int columnIndex) throws java.rmi.RemoteException , SQLException;
582
583     /**
584      * JDBC 2.0
585      *
586      * Gets the value of a column in the current row as a java.math.BigDecimal
587      * object with full precision.
588      * @param columnName the column name
589      * @return the column value (full precision); if the value is SQL NULL,
590      * the result is null
591      * @exception SQLException if a database access error occurs
592      *
593      */
594     BigDecimal getBigDecimal(String columnName) throws java.rmi.RemoteException , SQLException;
595
596     //---------------------------------------------------------------------
597 // Traversal/Positioning
598 //---------------------------------------------------------------------
599
600     /**
601      * JDBC 2.0
602      *
603      * <p>Indicates whether the cursor is before the first row in the result
604      * set.
605      *
606      * @return true if the cursor is before the first row, false otherwise. Returns
607      * false when the result set contains no rows.
608      * @exception SQLException if a database access error occurs
609      */
610     boolean isBeforeFirst() throws java.rmi.RemoteException , SQLException;
611       
612     /**
613      * JDBC 2.0
614      *
615      * <p>Indicates whether the cursor is after the last row in the result
616      * set.
617      *
618      * @return true if the cursor is after the last row, false otherwise. Returns
619      * false when the result set contains no rows.
620      * @exception SQLException if a database access error occurs
621      */
622     boolean isAfterLast() throws java.rmi.RemoteException , SQLException;
623  
624     /**
625      * JDBC 2.0
626      *
627      * <p>Indicates whether the cursor is on the first row of the result set.
628      *
629      * @return true if the cursor is on the first row, false otherwise.
630      * @exception SQLException if a database access error occurs
631      */
632     boolean isFirst() throws java.rmi.RemoteException , SQLException;
633  
634     /**
635      * JDBC 2.0
636      *
637      * <p>Indicates whether the cursor is on the last row of the result set.
638      * Note: Calling the method <code>isLast</code> may be expensive
639      * because the JDBC driver
640      * might need to fetch ahead one row in order to determine
641      * whether the current row is the last row in the result set.
642      *
643      * @return true if the cursor is on the last row, false otherwise.
644      * @exception SQLException if a database access error occurs
645      */
646     boolean isLast() throws java.rmi.RemoteException , SQLException;
647
648     /**
649      * JDBC 2.0
650      *
651      * <p>Moves the cursor to the front of the result set, just before the
652      * first row. Has no effect if the result set contains no rows.
653      *
654      * @exception SQLException if a database access error occurs or the
655      * result set type is TYPE_FORWARD_ONLY
656      */
657     void beforeFirst() throws java.rmi.RemoteException , SQLException;
658
659     /**
660      * JDBC 2.0
661      *
662      * <p>Moves the cursor to the end of the result set, just after the last
663      * row. Has no effect if the result set contains no rows.
664      *
665      * @exception SQLException if a database access error occurs or the
666      * result set type is TYPE_FORWARD_ONLY
667      */
668     void afterLast() throws java.rmi.RemoteException , SQLException;
669
670     /**
671      * JDBC 2.0
672      *
673      * <p>Moves the cursor to the first row in the result set.
674      *
675      * @return true if the cursor is on a valid row; false if
676      * there are no rows in the result set
677      * @exception SQLException if a database access error occurs or the
678      * result set type is TYPE_FORWARD_ONLY
679      */
680     boolean first() throws java.rmi.RemoteException , SQLException;
681
682     /**
683      * JDBC 2.0
684      *
685      * <p>Moves the cursor to the last row in the result set.
686      *
687      * @return true if the cursor is on a valid row;
688      * false if there are no rows in the result set
689      * @exception SQLException if a database access error occurs or the
690      * result set type is TYPE_FORWARD_ONLY.
691      */
692     boolean last() throws java.rmi.RemoteException , SQLException;
693
694     /**
695      * JDBC 2.0
696      *
697      * <p>Retrieves the current row number. The first row is number 1, the
698      * second number 2, and so on.
699      *
700      * @return the current row number; 0 if there is no current row
701      * @exception SQLException if a database access error occurs
702      */
703     int getRow() throws java.rmi.RemoteException , SQLException;
704
705     /**
706      * JDBC 2.0
707      *
708      * <p>Moves the cursor to the given row number in the result set.
709      *
710      * <p>If the row number is positive, the cursor moves to
711      * the given row number with respect to the
712      * beginning of the result set. The first row is row 1, the second
713      * is row 2, and so on.
714      *
715      * <p>If the given row number is negative, the cursor moves to
716      * an absolute row position with respect to
717      * the end of the result set. For example, calling
718      * <code>absolute(-1)</code> positions the
719      * cursor on the last row, <code>absolute(-2)</code> indicates the next-to-last
720      * row, and so on.
721      *
722      * <p>An attempt to position the cursor beyond the first/last row in
723      * the result set leaves the cursor before/after the first/last
724      * row, respectively.
725      *
726      * <p>Note: Calling <code>absolute(1)</code> is the same
727      * as calling <code>first()</code>.
728      * Calling <code>absolute(-1)</code> is the same as calling <code>last()</code>.
729      *
730      * @return true if the cursor is on the result set; false otherwise
731      * @exception SQLException if a database access error occurs or
732      * row is 0, or result set type is TYPE_FORWARD_ONLY.
733      */
734     boolean absolute( int row ) throws java.rmi.RemoteException , SQLException;
735
736     /**
737      * JDBC 2.0
738      *
739      * <p>Moves the cursor a relative number of rows, either positive or negative.
740      * Attempting to move beyond the first/last row in the
741      * result set positions the cursor before/after the
742      * the first/last row. Calling <code>relative(0)</code> is valid, but does
743      * not change the cursor position.
744      *
745      * <p>Note: Calling <code>relative(1)</code>
746      * is different from calling <code>next()</code>
747      * because is makes sense to call <code>next()</code> when there is no current row,
748      * for example, when the cursor is positioned before the first row
749      * or after the last row of the result set.
750      *
751      * @return true if the cursor is on a row; false otherwise
752      * @exception SQLException if a database access error occurs, there
753      * is no current row, or the result set type is TYPE_FORWARD_ONLY
754      */
755     boolean relative( int rows ) throws java.rmi.RemoteException , SQLException;
756
757     /**
758      * JDBC 2.0
759      *
760      * <p>Moves the cursor to the previous row in the result set.
761      *
762      * <p>Note: <code>previous()</code> is not the same as
763      * <code>relative(-1)</code> because it
764      * makes sense to call</code>previous()</code> when there is no current row.
765      *
766      * @return true if the cursor is on a valid row; false if it is off the result set
767      * @exception SQLException if a database access error occurs or the
768      * result set type is TYPE_FORWARD_ONLY
769      */
770     boolean previous() throws java.rmi.RemoteException , SQLException;
771
772     /**
773      * JDBC 2.0
774      *
775      * Gives a hint as to the direction in which the rows in this result set
776      * will be processed. The initial value is determined by the statement
777      * that produced the result set. The fetch direction may be changed
778      * at any time.
779      *
780      * @exception SQLException if a database access error occurs or
781      * the result set type is TYPE_FORWARD_ONLY and the fetch direction is not
782      * FETCH_FORWARD.
783      */
784     void setFetchDirection(int direction) throws java.rmi.RemoteException , SQLException;
785
786     /**
787      * JDBC 2.0
788      *
789      * Returns the fetch direction for this result set.
790      *
791      * @return the current fetch direction for this result set
792      * @exception SQLException if a database access error occurs
793      */
794     int getFetchDirection() throws java.rmi.RemoteException , SQLException;
795
796     /**
797      * JDBC 2.0
798      *
799      * Gives the JDBC driver a hint as to the number of rows that should
800      * be fetched from the database when more rows are needed for this result
801      * set. If the fetch size specified is zero, the JDBC driver
802      * ignores the value and is free to make its own best guess as to what
803      * the fetch size should be. The default value is set by the statement
804      * that created the result set. The fetch size may be changed at any
805      * time.
806      *
807      * @param rows the number of rows to fetch
808      * @exception SQLException if a database access error occurs or the
809      * condition 0 <= rows <= this.getMaxRows() is not satisfied.
810      */
811     void setFetchSize(int rows) throws java.rmi.RemoteException , SQLException;
812
813     /**
814      * JDBC 2.0
815      *
816      * Returns the fetch size for this result set.
817      *
818      * @return the current fetch size for this result set
819      * @exception SQLException if a database access error occurs
820      */
821     int getFetchSize() throws java.rmi.RemoteException , SQLException;
822
823
824     /**
825      * JDBC 2.0
826      *
827      * Returns the type of this result set. The type is determined by
828      * the statement that created the result set.
829      *
830      * @return TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE, or
831      * TYPE_SCROLL_SENSITIVE
832      * @exception SQLException if a database access error occurs
833      */
834     int getType() throws java.rmi.RemoteException , SQLException;
835
836     /**
837      * JDBC 2.0
838      *
839      * Returns the concurrency mode of this result set. The concurrency
840      * used is determined by the statement that created the result set.
841      *
842      * @return the concurrency type, CONCUR_READ_ONLY or CONCUR_UPDATABLE
843      * @exception SQLException if a database access error occurs
844      */
845     int getConcurrency() throws java.rmi.RemoteException , SQLException;
846
847     //---------------------------------------------------------------------
848 // Updates
849 //---------------------------------------------------------------------
850
851     /**
852      * JDBC 2.0
853      *
854      * Indicates whether the current row has been updated. The value returned
855      * depends on whether or not the result set can detect updates.
856      *
857      * @return true if the row has been visibly updated by the owner or
858      * another, and updates are detected
859      * @exception SQLException if a database access error occurs
860      *
861      * @see DatabaseMetaData#updatesAreDetected
862      */
863     boolean rowUpdated() throws java.rmi.RemoteException , SQLException;
864
865     /**
866      * JDBC 2.0
867      *
868      * Indicates whether the current row has had an insertion. The value returned
869      * depends on whether or not the result set can detect visible inserts.
870      *
871      * @return true if a row has had an insertion and insertions are detected
872      * @exception SQLException if a database access error occurs
873      *
874      * @see DatabaseMetaData#insertsAreDetected
875      */
876     boolean rowInserted() throws java.rmi.RemoteException , SQLException;
877    
878     /**
879      * JDBC 2.0
880      *
881      * Indicates whether a row has been deleted. A deleted row may leave
882      * a visible "hole" in a result set. This method can be used to
883      * detect holes in a result set. The value returned depends on whether
884      * or not the result set can detect deletions.
885      *
886      * @return true if a row was deleted and deletions are detected
887      * @exception SQLException if a database access error occurs
888      *
889      * @see DatabaseMetaData#deletesAreDetected
890      */
891     boolean rowDeleted() throws java.rmi.RemoteException , SQLException;
892
893     /**
894      * JDBC 2.0
895      *
896      * Give a nullable column a null value.
897      *
898      * The <code>updateXXX</code> methods are used to update column values in the
899      * current row, or the insert row. The <code>updateXXX</code> methods do not
900      * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
901      * methods are called to update the database.
902      *
903      * @param columnIndex the first column is 1, the second is 2, ...
904      * @exception SQLException if a database access error occurs
905      */
906     void updateNull(int columnIndex) throws java.rmi.RemoteException , SQLException;
907
908     /**
909      * JDBC 2.0
910      *
911      * Updates a column with a boolean value.
912      *
913      * The <code>updateXXX</code> methods are used to update column values in the
914      * current row, or the insert row. The <code>updateXXX</code> methods do not
915      * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
916      * methods are called to update the database.
917      *
918      * @param columnIndex the first column is 1, the second is 2, ...
919      * @param x the new column value
920      * @exception SQLException if a database access error occurs
921      */
922     void updateBoolean(int columnIndex, boolean x) throws java.rmi.RemoteException , SQLException;
923
924     /**
925      * JDBC 2.0
926      *
927      * Updates a column with a byte value.
928      *
929      * The <code>updateXXX</code> methods are used to update column values in the
930      * current row, or the insert row. The <code>updateXXX</code> methods do not
931      * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
932      * methods are called to update the database.
933      *
934      * @param columnIndex the first column is 1, the second is 2, ...
935      * @param x the new column value
936      * @exception SQLException if a database access error occurs
937      */
938     void updateByte(int columnIndex, byte x) throws java.rmi.RemoteException , SQLException;
939
940     /**
941      * JDBC 2.0
942      *
943      * Updates a column with a short value.
944      *
945      * The <code>updateXXX</code> methods are used to update column values in the
946      * current row, or the insert row. The <code>updateXXX</code> methods do not
947      * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
948      * methods are called to update the database.
949      *
950      * @param columnIndex the first column is 1, the second is 2, ...
951      * @param x the new column value
952      * @exception SQLException if a database access error occurs
953      */
954     void updateShort(int columnIndex, short x) throws java.rmi.RemoteException , SQLException;
955
956     /**
957      * JDBC 2.0
958      *
959      * Updates a column with an integer value.
960      *
961      * The <code>updateXXX</code> methods are used to update column values in the
962      * current row, or the insert row. The <code>updateXXX</code> methods do not
963      * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
964      * methods are called to update the database.
965      *
966      * @param columnIndex the first column is 1, the second is 2, ...
967      * @param x the new column value
968      * @exception SQLException if a database access error occurs
969      */
970     void updateInt(int columnIndex, int x) throws java.rmi.RemoteException , SQLException;
971
972     /**
973      * JDBC 2.0
974      *
975      * Updates a column with a long value.
976      *
977      * The <code>updateXXX</code> methods are used to update column values in the
978      * current row, or the insert row. The <code>updateXXX</code> methods do not
979      * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
980      * methods are called to update the database.
981      *
982      * @param columnIndex the first column is 1, the second is 2, ...
983      * @param x the new column value
984      * @exception SQLException if a database access error occurs
985      */
986     void updateLong(int columnIndex, long x) throws java.rmi.RemoteException , SQLException;
987
988     /**
989      * JDBC 2.0
990      *
991      * Updates a column with a float value.
992      *
993      * The <code>updateXXX</code> methods are used to update column values in the
994      * current row, or the insert row. The <code>updateXXX</code> methods do not
995      * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
996      * methods are called to update the database.
997      *
998      * @param columnIndex the first column is 1, the second is 2, ...
999      * @param x the new column value
1000     * @exception SQLException if a database access error occurs
1001     */
1002    void updateFloat(int columnIndex, float x) throws java.rmi.RemoteException , SQLException;
1003
1004    /**
1005     * JDBC 2.0
1006     *
1007     * Updates a column with a Double value.
1008     *
1009     * The <code>updateXXX</code> methods are used to update column values in the
1010     * current row, or the insert row. The <code>updateXXX</code> methods do not
1011     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1012     * methods are called to update the database.
1013     *
1014     * @param columnIndex the first column is 1, the second is 2, ...
1015     * @param x the new column value
1016     * @exception SQLException if a database access error occurs
1017     */
1018    void updateDouble(int columnIndex, double x) throws java.rmi.RemoteException , SQLException;
1019
1020    /**
1021     * JDBC 2.0
1022     *
1023     * Updates a column with a BigDecimal value.
1024     *
1025     * The <code>updateXXX</code> methods are used to update column values in the
1026     * current row, or the insert row. The <code>updateXXX</code> methods do not
1027     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1028     * methods are called to update the database.
1029     *
1030     * @param columnIndex the first column is 1, the second is 2, ...
1031     * @param x the new column value
1032     * @exception SQLException if a database access error occurs
1033     */
1034    void updateBigDecimal(int columnIndex, BigDecimal x) throws java.rmi.RemoteException , SQLException;
1035
1036    /**
1037     * JDBC 2.0
1038     *
1039     * Updates a column with a String value.
1040     *
1041     * The <code>updateXXX</code> methods are used to update column values in the
1042     * current row, or the insert row. The <code>updateXXX</code> methods do not
1043     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1044     * methods are called to update the database.
1045     *
1046     * @param columnIndex the first column is 1, the second is 2, ...
1047     * @param x the new column value
1048     * @exception SQLException if a database access error occurs
1049     */
1050    void updateString(int columnIndex, String x) throws java.rmi.RemoteException , SQLException;
1051
1052    /**
1053     * JDBC 2.0
1054     *
1055     * Updates a column with a byte array value.
1056     *
1057     * The <code>updateXXX</code> methods are used to update column values in the
1058     * current row, or the insert row. The <code>updateXXX</code> methods do not
1059     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1060     * methods are called to update the database.
1061     *
1062     * @param columnIndex the first column is 1, the second is 2, ...
1063     * @param x the new column value
1064     * @exception SQLException if a database access error occurs
1065     */
1066    void updateBytes(int columnIndex, byte x[]) throws java.rmi.RemoteException , SQLException;
1067
1068    /**
1069     * JDBC 2.0
1070     *
1071     * Updates a column with a Date value.
1072     *
1073     * The <code>updateXXX</code> methods are used to update column values in the
1074     * current row, or the insert row. The <code>updateXXX</code> methods do not
1075     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1076     * methods are called to update the database.
1077     *
1078     * @param columnIndex the first column is 1, the second is 2, ...
1079     * @param x the new column value
1080     * @exception SQLException if a database access error occurs
1081     */
1082    void updateDate(int columnIndex, java.sql.Date x) throws java.rmi.RemoteException , SQLException;
1083
1084    /**
1085     * JDBC 2.0
1086     *
1087     * Updates a column with a Time value.
1088     *
1089     * The <code>updateXXX</code> methods are used to update column values in the
1090     * current row, or the insert row. The <code>updateXXX</code> methods do not
1091     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1092     * methods are called to update the database.
1093     *
1094     * @param columnIndex the first column is 1, the second is 2, ...
1095     * @param x the new column value
1096     * @exception SQLException if a database access error occurs
1097     */
1098    void updateTime(int columnIndex, java.sql.Time x) throws java.rmi.RemoteException , SQLException;
1099
1100    /**
1101     * JDBC 2.0
1102     *
1103     * Updates a column with a Timestamp value.
1104     *
1105     * The <code>updateXXX</code> methods are used to update column values in the
1106     * current row, or the insert row. The <code>updateXXX</code> methods do not
1107     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1108     * methods are called to update the database.
1109     *
1110     * @param columnIndex the first column is 1, the second is 2, ...
1111     * @param x the new column value
1112     * @exception SQLException if a database access error occurs
1113     */
1114    void updateTimestamp(int columnIndex, java.sql.Timestamp x)
1115      throws java.rmi.RemoteException , SQLException;
1116
1117    /**
1118     * JDBC 2.0
1119     *
1120     * Updates a column with an ascii stream value.
1121     *
1122     * The <code>updateXXX</code> methods are used to update column values in the
1123     * current row, or the insert row. The <code>updateXXX</code> methods do not
1124     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1125     * methods are called to update the database.
1126     *
1127     * @param columnIndex the first column is 1, the second is 2, ...
1128     * @param x the new column value
1129     * @param length the length of the stream
1130     * @exception SQLException if a database access error occurs
1131     */
1132    void updateAsciiStream(int columnIndex,
1133               java.io.InputStream x,
1134               int length) throws java.rmi.RemoteException , SQLException;
1135
1136    /**
1137     * JDBC 2.0
1138     *
1139     * Updates a column with a binary stream value.
1140     *
1141     * The <code>updateXXX</code> methods are used to update column values in the
1142     * current row, or the insert row. The <code>updateXXX</code> methods do not
1143     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1144     * methods are called to update the database.
1145     *
1146     * @param columnIndex the first column is 1, the second is 2, ...
1147     * @param x the new column value
1148     * @param length the length of the stream
1149     * @exception SQLException if a database access error occurs
1150     */
1151    void updateBinaryStream(int columnIndex,
1152                java.io.InputStream x,
1153                int length) throws java.rmi.RemoteException , SQLException;
1154
1155    /**
1156     * JDBC 2.0
1157     *
1158     * Updates a column with a character stream value.
1159     *
1160     * The <code>updateXXX</code> methods are used to update column values in the
1161     * current row, or the insert row. The <code>updateXXX</code> methods do not
1162     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1163     * methods are called to update the database.
1164     *
1165     * @param columnIndex the first column is 1, the second is 2, ...
1166     * @param x the new column value
1167     * @param length the length of the stream
1168     * @exception SQLException if a database access error occurs
1169     */
1170    void updateCharacterStream(int columnIndex,
1171                 java.io.Reader x,
1172                 int length) throws java.rmi.RemoteException , SQLException;
1173
1174    /**
1175     * JDBC 2.0
1176     *
1177     * Updates a column with an Object value.
1178     *
1179     * The <code>updateXXX</code> methods are used to update column values in the
1180     * current row, or the insert row. The <code>updateXXX</code> methods do not
1181     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1182     * methods are called to update the database.
1183     *
1184     * @param columnIndex the first column is 1, the second is 2, ...
1185     * @param x the new column value
1186     * @param scale For java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types
1187     * this is the number of digits after the decimal. For all other
1188     * types this value will be ignored.
1189     * @exception SQLException if a database access error occurs
1190     */
1191    void updateObject(int columnIndex, Object x, int scale)
1192      throws java.rmi.RemoteException , SQLException;
1193
1194    /**
1195     * JDBC 2.0
1196     *
1197     * Updates a column with an Object value.
1198     *
1199     * The <code>updateXXX</code> methods are used to update column values in the
1200     * current row, or the insert row. The <code>updateXXX</code> methods do not
1201     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1202     * methods are called to update the database.
1203     *
1204     * @param columnIndex the first column is 1, the second is 2, ...
1205     * @param x the new column value
1206     * @exception SQLException if a database access error occurs
1207     */
1208    void updateObject(int columnIndex, Object x) throws java.rmi.RemoteException , SQLException;
1209
1210    /**
1211     * JDBC 2.0
1212     *
1213     * Updates a column with a null value.
1214     *
1215     * The <code>updateXXX</code> methods are used to update column values in the
1216     * current row, or the insert row. The <code>updateXXX</code> methods do not
1217     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1218     * methods are called to update the database.
1219     *
1220     * @param columnName the name of the column
1221     * @exception SQLException if a database access error occurs
1222     */
1223    void updateNull(String columnName) throws java.rmi.RemoteException , SQLException;
1224
1225    /**
1226     * JDBC 2.0
1227     *
1228     * Updates a column with a boolean value.
1229     *
1230     * The <code>updateXXX</code> methods are used to update column values in the
1231     * current row, or the insert row. The <code>updateXXX</code> methods do not
1232     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1233     * methods are called to update the database.
1234     *
1235     * @param columnName the name of the column
1236     * @param x the new column value
1237     * @exception SQLException if a database access error occurs
1238     */
1239    void updateBoolean(String columnName, boolean x) throws java.rmi.RemoteException , SQLException;
1240
1241    /**
1242     * JDBC 2.0
1243     *
1244     * Updates a column with a byte value.
1245     *
1246     * The <code>updateXXX</code> methods are used to update column values in the
1247     * current row, or the insert row. The <code>updateXXX</code> methods do not
1248     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1249     * methods are called to update the database.
1250     *
1251     * @param columnName the name of the column
1252     * @param x the new column value
1253     * @exception SQLException if a database access error occurs
1254     */
1255    void updateByte(String columnName, byte x) throws java.rmi.RemoteException , SQLException;
1256
1257    /**
1258     * JDBC 2.0
1259     *
1260     * Updates a column with a short value.
1261     *
1262     * The <code>updateXXX</code> methods are used to update column values in the
1263     * current row, or the insert row. The <code>updateXXX</code> methods do not
1264     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1265     * methods are called to update the database.
1266     *
1267     * @param columnName the name of the column
1268     * @param x the new column value
1269     * @exception SQLException if a database access error occurs
1270     */
1271    void updateShort(String columnName, short x) throws java.rmi.RemoteException , SQLException;
1272
1273    /**
1274     * JDBC 2.0
1275     *
1276     * Updates a column with an integer value.
1277     *
1278     * The <code>updateXXX</code> methods are used to update column values in the
1279     * current row, or the insert row. The <code>updateXXX</code> methods do not
1280     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1281     * methods are called to update the database.
1282     *
1283     * @param columnName the name of the column
1284     * @param x the new column value
1285     * @exception SQLException if a database access error occurs
1286     */
1287    void updateInt(String columnName, int x) throws java.rmi.RemoteException , SQLException;
1288
1289    /**
1290     * JDBC 2.0
1291     *
1292     * Updates a column with a long value.
1293     *
1294     * The <code>updateXXX</code> methods are used to update column values in the
1295     * current row, or the insert row. The <code>updateXXX</code> methods do not
1296     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1297     * methods are called to update the database.
1298     *
1299     * @param columnName the name of the column
1300     * @param x the new column value
1301     * @exception SQLException if a database access error occurs
1302     */
1303    void updateLong(String columnName, long x) throws java.rmi.RemoteException , SQLException;
1304
1305    /**
1306     * JDBC 2.0
1307     *
1308     * Updates a column with a float value.
1309     *
1310     * The <code>updateXXX</code> methods are used to update column values in the
1311     * current row, or the insert row. The <code>updateXXX</code> methods do not
1312     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1313     * methods are called to update the database.
1314     *
1315     * @param columnName the name of the column
1316     * @param x the new column value
1317     * @exception SQLException if a database access error occurs
1318     */
1319    void updateFloat(String columnName, float x) throws java.rmi.RemoteException , SQLException;
1320
1321    /**
1322     * JDBC 2.0
1323     *
1324     * Updates a column with a double value.
1325     *
1326     * The <code>updateXXX</code> methods are used to update column values in the
1327     * current row, or the insert row. The <code>updateXXX</code> methods do not
1328     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1329     * methods are called to update the database.
1330     *
1331     * @param columnName the name of the column
1332     * @param x the new column value
1333     * @exception SQLException if a database access error occurs
1334     */
1335    void updateDouble(String columnName, double x) throws java.rmi.RemoteException , SQLException;
1336
1337    /**
1338     * JDBC 2.0
1339     *
1340     * Updates a column with a BigDecimal value.
1341     *
1342     * The <code>updateXXX</code> methods are used to update column values in the
1343     * current row, or the insert row. The <code>updateXXX</code> methods do not
1344     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1345     * methods are called to update the database.
1346     *
1347     * @param columnName the name of the column
1348     * @param x the new column value
1349     * @exception SQLException if a database access error occurs
1350     */
1351    void updateBigDecimal(String columnName, BigDecimal x) throws java.rmi.RemoteException , SQLException;
1352
1353    /**
1354     * JDBC 2.0
1355     *
1356     * Updates a column with a String value.
1357     *
1358     * The <code>updateXXX</code> methods are used to update column values in the
1359     * current row, or the insert row. The <code>updateXXX</code> methods do not
1360     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1361     * methods are called to update the database.
1362     *
1363     * @param columnName the name of the column
1364     * @param x the new column value
1365     * @exception SQLException if a database access error occurs
1366     */
1367    void updateString(String columnName, String x) throws java.rmi.RemoteException , SQLException;
1368
1369    /**
1370     * JDBC 2.0
1371     *
1372     * Updates a column with a byte array value.
1373     *
1374     * The <code>updateXXX</code> methods are used to update column values in the
1375     * current row, or the insert row. The <code>updateXXX</code> methods do not
1376     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1377     * methods are called to update the database.
1378     *
1379     * @param columnName the name of the column
1380     * @param x the new column value
1381     * @exception SQLException if a database access error occurs
1382     */
1383    void updateBytes(String columnName, byte x[]) throws java.rmi.RemoteException , SQLException;
1384
1385    /**
1386     * JDBC 2.0
1387     *
1388     * Updates a column with a Date value.
1389     *
1390     * The <code>updateXXX</code> methods are used to update column values in the
1391     * current row, or the insert row. The <code>updateXXX</code> methods do not
1392     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1393     * methods are called to update the database.
1394     *
1395     * @param columnName the name of the column
1396     * @param x the new column value
1397     * @exception SQLException if a database access error occurs
1398     */
1399    void updateDate(String columnName, java.sql.Date x) throws java.rmi.RemoteException , SQLException;
1400
1401    /**
1402     * JDBC 2.0
1403     *
1404     * Updates a column with a Time value.
1405     *
1406     * The <code>updateXXX</code> methods are used to update column values in the
1407     * current row, or the insert row. The <code>updateXXX</code> methods do not
1408     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1409     * methods are called to update the database.
1410     *
1411     * @param columnName the name of the column
1412     * @param x the new column value
1413     * @exception SQLException if a database access error occurs
1414     */
1415    void updateTime(String columnName, java.sql.Time x) throws java.rmi.RemoteException , SQLException;
1416
1417    /**
1418     * JDBC 2.0
1419     *
1420     * Updates a column with a Timestamp value.
1421     *
1422     * The <code>updateXXX</code> methods are used to update column values in the
1423     * current row, or the insert row. The <code>updateXXX</code> methods do not
1424     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1425     * methods are called to update the database.
1426     *
1427     * @param columnName the name of the column
1428     * @param x the new column value
1429     * @exception SQLException if a database access error occurs
1430     */
1431    void updateTimestamp(String columnName, java.sql.Timestamp x)
1432      throws java.rmi.RemoteException , SQLException;
1433
1434    /**
1435     * JDBC 2.0
1436     *
1437     * Updates a column with an ascii stream value.
1438     *
1439     * The <code>updateXXX</code> methods are used to update column values in the
1440     * current row, or the insert row. The <code>updateXXX</code> methods do not
1441     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1442     * methods are called to update the database.
1443     *
1444     * @param columnName the name of the column
1445     * @param x the new column value
1446     * @param length of the stream
1447     * @exception SQLException if a database access error occurs
1448     */
1449    void updateAsciiStream(String columnName,
1450               java.io.InputStream x,
1451               int length) throws java.rmi.RemoteException , SQLException;
1452
1453    /**
1454     * JDBC 2.0
1455     *
1456     * Updates a column with a binary stream value.
1457     *
1458     * The <code>updateXXX</code> methods are used to update column values in the
1459     * current row, or the insert row. The <code>updateXXX</code> methods do not
1460     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1461     * methods are called to update the database.
1462     *
1463     * @param columnName the name of the column
1464     * @param x the new column value
1465     * @param length of the stream
1466     * @exception SQLException if a database access error occurs
1467     */
1468    void updateBinaryStream(String columnName,
1469                java.io.InputStream x,
1470                int length) throws java.rmi.RemoteException , SQLException;
1471
1472    /**
1473     * JDBC 2.0
1474     *
1475     * Updates a column with a character stream value.
1476     *
1477     * The <code>updateXXX</code> methods are used to update column values in the
1478     * current row, or the insert row. The <code>updateXXX</code> methods do not
1479     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1480     * methods are called to update the database.
1481     *
1482     * @param columnName the name of the column
1483     * @param x the new column value
1484     * @param length of the stream
1485     * @exception SQLException if a database access error occurs
1486     */
1487    void updateCharacterStream(String columnName,
1488                 java.io.Reader reader,
1489                 int length) throws java.rmi.RemoteException , SQLException;
1490
1491    /**
1492     * JDBC 2.0
1493     *
1494     * Updates a column with an Object value.
1495     *
1496     * The <code>updateXXX</code> methods are used to update column values in the
1497     * current row, or the insert row. The <code>updateXXX</code> methods do not
1498     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1499     * methods are called to update the database.
1500     *
1501     * @param columnName the name of the column
1502     * @param x the new column value
1503     * @param scale For java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types
1504     * this is the number of digits after the decimal. For all other
1505     * types this value will be ignored.
1506     * @exception SQLException if a database access error occurs
1507     */
1508    void updateObject(String columnName, Object x, int scale)
1509      throws java.rmi.RemoteException , SQLException;
1510
1511    /**
1512     * JDBC 2.0
1513     *
1514     * Updates a column with an Object value.
1515     *
1516     * The <code>updateXXX</code> methods are used to update column values in the
1517     * current row, or the insert row. The <code>updateXXX</code> methods do not
1518     * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1519     * methods are called to update the database.
1520     *
1521     * @param columnName the name of the column
1522     * @param x the new column value
1523     * @exception SQLException if a database access error occurs
1524     */
1525    void updateObject(String columnName, Object x) throws java.rmi.RemoteException , SQLException;
1526
1527    /**
1528     * JDBC 2.0
1529     *
1530     * Inserts the contents of the insert row into the result set and
1531     * the database. Must be on the insert row when this method is called.
1532     *
1533     * @exception SQLException if a database access error occurs,
1534     * if called when not on the insert row, or if not all of non-nullable columns in
1535     * the insert row have been given a value
1536     */
1537    void insertRow() throws java.rmi.RemoteException , SQLException;
1538
1539    /**
1540     * JDBC 2.0
1541     *
1542     * Updates the underlying database with the new contents of the
1543     * current row. Cannot be called when on the insert row.
1544     *
1545     * @exception SQLException if a database access error occurs or
1546     * if called when on the insert row
1547     */
1548    void updateRow() throws java.rmi.RemoteException , SQLException;
1549
1550    /**
1551     * JDBC 2.0
1552     *
1553     * Deletes the current row from the result set and the underlying
1554     * database. Cannot be called when on the insert row.
1555     *
1556     * @exception SQLException if a database access error occurs or if
1557     * called when on the insert row.
1558     */
1559    void deleteRow() throws java.rmi.RemoteException , SQLException;
1560
1561    /**
1562     * JDBC 2.0
1563     *
1564     * Refreshes the current row with its most recent value in
1565     * the database. Cannot be called when on the insert row.
1566     *
1567     * The <code>refreshRow</code> method provides a way for an application to
1568     * explicitly tell the JDBC driver to refetch a row(s) from the
1569     * database. An application may want to call <code>refreshRow</code> when
1570     * caching or prefetching is being done by the JDBC driver to
1571     * fetch the latest value of a row from the database. The JDBC driver
1572     * may actually refresh multiple rows at once if the fetch size is
1573     * greater than one.
1574     *
1575     * All values are refetched subject to the transaction isolation
1576     * level and cursor sensitivity. If <code>refreshRow</code> is called after
1577     * calling <code>updateXXX</code>, but before calling <code>updateRow</code>, then the
1578     * updates made to the row are lost. Calling the method <code>refreshRow</code> frequently
1579     * will likely slow performance.
1580     *
1581     * @exception SQLException if a database access error occurs or if
1582     * called when on the insert row
1583     */
1584    void refreshRow() throws java.rmi.RemoteException , SQLException;
1585
1586    /**
1587     * JDBC 2.0
1588     *
1589     * Cancels the updates made to a row.
1590     * This method may be called after calling an
1591     * <code>updateXXX</code> method(s) and before calling <code>updateRow</code> to rollback
1592     * the updates made to a row. If no updates have been made or
1593     * <code>updateRow</code> has already been called, then this method has no
1594     * effect.
1595     *
1596     * @exception SQLException if a database access error occurs or if
1597     * called when on the insert row
1598     *
1599     */
1600    void cancelRowUpdates() throws java.rmi.RemoteException , SQLException;
1601
1602    /**
1603     * JDBC 2.0
1604     *
1605     * Moves the cursor to the insert row. The current cursor position is
1606     * remembered while the cursor is positioned on the insert row.
1607     *
1608     * The insert row is a special row associated with an updatable
1609     * result set. It is essentially a buffer where a new row may
1610     * be constructed by calling the <code>updateXXX</code> methods prior to
1611     * inserting the row into the result set.
1612     *
1613     * Only the <code>updateXXX</code>, <code>getXXX</code>,
1614     * and <code>insertRow</code> methods may be
1615     * called when the cursor is on the insert row. All of the columns in
1616     * a result set must be given a value each time this method is
1617     * called before calling <code>insertRow</code>.
1618     * The method <code>updateXXX</code> must be called before a
1619     * <code>getXXX</code> method can be called on a column value.
1620     *
1621     * @exception SQLException if a database access error occurs
1622     * or the result set is not updatable
1623     */
1624    void moveToInsertRow() throws java.rmi.RemoteException , SQLException;
1625
1626    /**
1627     * JDBC 2.0
1628     *
1629     * Moves the cursor to the remembered cursor position, usually the
1630     * current row. This method has no effect if the cursor is not on the insert
1631     * row.
1632     *
1633     * @exception SQLException if a database access error occurs
1634     * or the result set is not updatable
1635     */
1636    void moveToCurrentRow() throws java.rmi.RemoteException , SQLException;
1637
1638    /**
1639     * JDBC 2.0
1640     *
1641     * Returns the Statement that produced this <code>ResultSet</code> object.
1642     * If the result set was generated some other way, such as by a
1643     * <code>DatabaseMetaData</code> method, this method returns <code>null</code>.
1644     *
1645     * @return the Statment that produced the result set or
1646     * null if the result set was produced some other way
1647     * @exception SQLException if a database access error occurs
1648     */
1649    RJStatementInterface getStatement()
1650    throws java.rmi.RemoteException , SQLException;
1651
1652    /**
1653     * JDBC 2.0
1654     *
1655     * Returns the value of a column in the current row as a Java object.
1656     * This method uses the given <code>Map</code> object
1657     * for the custom mapping of the
1658     * SQL structured or distinct type that is being retrieved.
1659     *
1660     * @param i the first column is 1, the second is 2, ...
1661     * @param map the mapping from SQL type names to Java classes
1662     * @return an object representing the SQL value
1663     */
1664    Object getObject(int i, java.util.Map map) throws java.rmi.RemoteException , SQLException;
1665
1666    /**
1667     * JDBC 2.0
1668     *
1669     * Gets a REF(&lt;structured-type&gt;) column value from the current row.
1670     *
1671     * @param i the first column is 1, the second is 2, ...
1672     * @return a <code>Ref</code> object representing an SQL REF value
1673     */
1674    RJRefInterface getRef(int i) throws java.rmi.RemoteException , SQLException;
1675
1676    /**
1677     * JDBC 2.0
1678     *
1679     * Gets a BLOB value in the current row of this <code>ResultSet</code> object.
1680     *
1681     * @param i the first column is 1, the second is 2, ...
1682     * @return a <code>Blob</code> object representing the SQL BLOB value in
1683     * the specified column
1684     */
1685    RJBlobInterface getBlob(int i)
1686    throws java.rmi.RemoteException , SQLException;
1687
1688    /**
1689     * JDBC 2.0
1690     *
1691     * Gets a CLOB value in the current row of this <code>ResultSet</code> object.
1692     *
1693     * @param i the first column is 1, the second is 2, ...
1694     * @return a <code>Clob</code> object representing the SQL CLOB value in
1695     * the specified column
1696     */
1697    RJClobInterface getClob(int i)
1698    throws java.rmi.RemoteException , SQLException;
1699
1700    /**
1701     * JDBC 2.0
1702     *
1703     * Gets an SQL ARRAY value from the current row of this <code>ResultSet</code> object.
1704     *
1705     * @param i the first column is 1, the second is 2, ...
1706     * @return an <code>Array</code> object representing the SQL ARRAY value in
1707     * the specified column
1708     */
1709    RJArrayInterface getArray(int i)
1710    throws java.rmi.RemoteException , SQLException;
1711
1712    /**
1713     * JDBC 2.0
1714     *
1715     * Returns the value in the specified column as a Java object.
1716     * This method uses the specified <code>Map</code> object for
1717     * custom mapping if appropriate.
1718     *
1719     * @param colName the name of the column from which to retrieve the value
1720     * @param map the mapping from SQL type names to Java classes
1721     * @return an object representing the SQL value in the specified column
1722     */
1723    Object getObject(String colName, java.util.Map map) throws java.rmi.RemoteException , SQLException;
1724
1725    /**
1726     * JDBC 2.0
1727     *
1728     * Gets a REF(&lt;structured-type&gt;) column value from the current row.
1729     *
1730     * @param colName the column name
1731     * @return a <code>Ref</code> object representing the SQL REF value in
1732     * the specified column
1733     */
1734    RJRefInterface getRef(String colName)
1735    throws java.rmi.RemoteException , SQLException;
1736
1737    /**
1738     * JDBC 2.0
1739     *
1740     * Gets a BLOB value in the current row of this <code>ResultSet</code> object.
1741     *
1742     * @param colName the name of the column from which to retrieve the value
1743     * @return a <code>Blob</code> object representing the SQL BLOB value in
1744     * the specified column
1745     */
1746    RJBlobInterface getBlob(String colName)
1747    throws java.rmi.RemoteException , SQLException;
1748
1749    /**
1750     * JDBC 2.0
1751     *
1752     * Gets a CLOB value in the current row of this <code>ResultSet</code> object.
1753     *
1754     * @param colName the name of the column from which to retrieve the value
1755     * @return a <code>Clob</code> object representing the SQL CLOB value in
1756     * the specified column
1757     */
1758    RJClobInterface getClob(String colName)
1759    throws java.rmi.RemoteException , SQLException;
1760
1761    /**
1762     * JDBC 2.0
1763     *
1764     * Gets an SQL ARRAY value in the current row of this <code>ResultSet</code> object.
1765     *
1766     * @param colName the name of the column from which to retrieve the value
1767     * @return an <code>Array</code> object representing the SQL ARRAY value in
1768     * the specified column
1769     */
1770    RJArrayInterface getArray(String colName)
1771    throws java.rmi.RemoteException , SQLException;
1772
1773    /**
1774     * JDBC 2.0
1775     *
1776     * Gets the value of a column in the current row as a java.sql.Date
1777     * object. This method uses the given calendar to construct an appropriate millisecond
1778     * value for the Date if the underlying database does not store
1779     * timezone information.
1780     *
1781     * @param columnIndex the first column is 1, the second is 2, ...
1782     * @param cal the calendar to use in constructing the date
1783     * @return the column value; if the value is SQL NULL, the result is null
1784     * @exception SQLException if a database access error occurs
1785     */
1786    java.sql.Date getDate(int columnIndex, Calendar cal) throws java.rmi.RemoteException , SQLException;
1787
1788    /**
1789     * Gets the value of a column in the current row as a java.sql.Date
1790     * object. This method uses the given calendar to construct an appropriate millisecond
1791     * value for the Date, if the underlying database does not store
1792     * timezone information.
1793     *
1794     * @param columnName the SQL name of the column from which to retrieve the value
1795     * @param cal the calendar to use in constructing the date
1796     * @return the column value; if the value is SQL NULL, the result is null
1797     * @exception SQLException if a database access error occurs
1798     */
1799    java.sql.Date getDate(String columnName, Calendar cal) throws java.rmi.RemoteException , SQLException;
1800
1801    /**
1802     * Gets the value of a column in the current row as a java.sql.Time
1803     * object. This method uses the given calendar to construct an appropriate millisecond
1804     * value for the Time if the underlying database does not store
1805     * timezone information.
1806     *
1807     * @param columnIndex the first column is 1, the second is 2, ...
1808     * @param cal the calendar to use in constructing the time
1809     * @return the column value; if the value is SQL NULL, the result is null
1810     * @exception SQLException if a database access error occurs
1811     */
1812    java.sql.Time getTime(int columnIndex, Calendar cal) throws java.rmi.RemoteException , SQLException;
1813
1814    /**
1815     * Gets the value of a column in the current row as a java.sql.Time
1816     * object. This method uses the given calendar to construct an appropriate millisecond
1817     * value for the Time if the underlying database does not store
1818     * timezone information.
1819     *
1820     * @param columnName the SQL name of the column
1821     * @param cal the calendar to use in constructing the time
1822     * @return the column value; if the value is SQL NULL, the result is null
1823     * @exception SQLException if a database access error occurs
1824     */
1825    java.sql.Time getTime(String columnName, Calendar cal) throws java.rmi.RemoteException , SQLException;
1826
1827    /**
1828     * Gets the value of a column in the current row as a java.sql.Timestamp
1829     * object. This method uses the given calendar to construct an appropriate millisecond
1830     * value for the Timestamp if the underlying database does not store
1831     * timezone information.
1832     *
1833     * @param columnIndex the first column is 1, the second is 2, ...
1834     * @param cal the calendar to use in constructing the timestamp
1835     * @return the column value; if the value is SQL NULL, the result is null
1836     * @exception SQLException if a database access error occurs
1837     */
1838    java.sql.Timestamp getTimestamp(int columnIndex, Calendar cal)
1839      throws java.rmi.RemoteException , SQLException;
1840
1841    /**
1842     * Gets the value of a column in the current row as a java.sql.Timestamp
1843     * object. This method uses the given calendar to construct an appropriate millisecond
1844     * value for the Timestamp if the underlying database does not store
1845     * timezone information.
1846     *
1847     * @param columnName the SQL name of the column
1848     * @param cal the calendar to use in constructing the timestamp
1849     * @return the column value; if the value is SQL NULL, the result is null
1850     * @exception SQLException if a database access error occurs
1851     */
1852    java.sql.Timestamp getTimestamp(String columnName, Calendar cal)
1853      throws java.rmi.RemoteException , SQLException;
1854
1855
1856    //-------------------------- JDBC 3.0 ----------------------------------------
1857
1858    /**
1859     * The constant indicating that <code>ResultSet</code> objects should not
1860     * be closed when the method <code>Connection.commit</code> is called.
1861     *
1862     * @since 1.4
1863     */
1864    int HOLD_CURSORS_OVER_COMMIT = 1;
1865
1866    /**
1867     * The constant indicating that <code>ResultSet</code> objects should be
1868     * closed when the method <code>Connection.commit</code> is called.
1869     *
1870     * @since 1.4
1871     */
1872    int CLOSE_CURSORS_AT_COMMIT = 2;
1873
1874    /**
1875     * Retrieves the value of the designated column in the current row
1876     * of this <code>ResultSet</code> object as a <code>java.net.URL</code>
1877     * object in the Java programming language.
1878     *
1879     * @param columnIndex the index of the column 1 is the first, 2 is the second,...
1880     * @return the column value as a <code>java.net.URL</code> object;
1881     * if the value is SQL <code>NULL</code>,
1882     * the value returned is <code>null</code> in the Java programming language
1883     * @exception SQLException if a database access error occurs,
1884     * or if a URL is malformed
1885     * @since 1.4
1886     */
1887    java.net.URL getURL(int columnIndex) throws java.rmi.RemoteException , SQLException;
1888
1889    /**
1890     * Retrieves the value of the designated column in the current row
1891     * of this <code>ResultSet</code> object as a <code>java.net.URL</code>
1892     * object in the Java programming language.
1893     *
1894     * @param columnName the SQL name of the column
1895     * @return the column value as a <code>java.net.URL</code> object;
1896     * if the value is SQL <code>NULL</code>,
1897     * the value returned is <code>null</code> in the Java programming language
1898     * @exception SQLException if a database access error occurs
1899     * or if a URL is malformed
1900     * @since 1.4
1901     */
1902    java.net.URL getURL(String columnName) throws java.rmi.RemoteException , SQLException;
1903
1904    /**
1905     * Updates the designated column with a <code>java.sql.Ref</code> value.
1906     * The updater methods are used to update column values in the
1907     * current row or the insert row. The updater methods do not
1908     * update the underlying database; instead the <code>updateRow</code> or
1909     * <code>insertRow</code> methods are called to update the database.
1910     *
1911     * @param columnIndex the first column is 1, the second is 2, ...
1912     * @param x the new column value
1913     * @exception SQLException if a database access error occurs
1914     * @since 1.4
1915     */
1916    void updateRef(int columnIndex, java.sql.Ref x) throws java.rmi.RemoteException , SQLException;
1917    
1918    /**
1919     * Updates the designated column with a <code>java.sql.Ref</code> value.
1920     * The updater methods are used to update column values in the
1921     * current row or the insert row. The updater methods do not
1922     * update the underlying database; instead the <code>updateRow</code> or
1923     * <code>insertRow</code> methods are called to update the database.
1924     *
1925     * @param columnName the name of the column
1926     * @param x the new column value
1927     * @exception SQLException if a database access error occurs
1928     * @since 1.4
1929     */
1930    void updateRef(String columnName, java.sql.Ref x) throws java.rmi.RemoteException , SQLException;
1931
1932    /**
1933     * Updates the designated column with a <code>java.sql.Blob</code> value.
1934     * The updater methods are used to update column values in the
1935     * current row or the insert row. The updater methods do not
1936     * update the underlying database; instead the <code>updateRow</code> or
1937     * <code>insertRow</code> methods are called to update the database.
1938     *
1939     * @param columnIndex the first column is 1, the second is 2, ...
1940     * @param x the new column value
1941     * @exception SQLException if a database access error occurs
1942     * @since 1.4
1943     */
1944    void updateBlob(int columnIndex, java.sql.Blob x) throws java.rmi.RemoteException , SQLException;
1945
1946    /**
1947     * Updates the designated column with a <code>java.sql.Blob</code> value.
1948     * The updater methods are used to update column values in the
1949     * current row or the insert row. The updater methods do not
1950     * update the underlying database; instead the <code>updateRow</code> or
1951     * <code>insertRow</code> methods are called to update the database.
1952     *
1953     * @param columnName the name of the column
1954     * @param x the new column value
1955     * @exception SQLException if a database access error occurs
1956     * @since 1.4
1957     */
1958    void updateBlob(String columnName, java.sql.Blob x) throws java.rmi.RemoteException , SQLException;
1959
1960    /**
1961     * Updates the designated column with a <code>java.sql.Clob</code> value.
1962     * The updater methods are used to update column values in the
1963     * current row or the insert row. The updater methods do not
1964     * update the underlying database; instead the <code>updateRow</code> or
1965     * <code>insertRow</code> methods are called to update the database.
1966     *
1967     * @param columnIndex the first column is 1, the second is 2, ...
1968     * @param x the new column value
1969     * @exception SQLException if a database access error occurs
1970     * @since 1.4
1971     */
1972    void updateClob(int columnIndex, java.sql.Clob x) throws java.rmi.RemoteException , SQLException;
1973
1974    /**
1975     * Updates the designated column with a <code>java.sql.Clob</code> value.
1976     * The updater methods are used to update column values in the
1977     * current row or the insert row. The updater methods do not
1978     * update the underlying database; instead the <code>updateRow</code> or
1979     * <code>insertRow</code> methods are called to update the database.
1980     *
1981     * @param columnName the name of the column
1982     * @param x the new column value
1983     * @exception SQLException if a database access error occurs
1984     * @since 1.4
1985     */
1986    void updateClob(String columnName, java.sql.Clob x) throws java.rmi.RemoteException , SQLException;
1987
1988    /**
1989     * Updates the designated column with a <code>java.sql.Array</code> value.
1990     * The updater methods are used to update column values in the
1991     * current row or the insert row. The updater methods do not
1992     * update the underlying database; instead the <code>updateRow</code> or
1993     * <code>insertRow</code> methods are called to update the database.
1994     *
1995     * @param columnIndex the first column is 1, the second is 2, ...
1996     * @param x the new column value
1997     * @exception SQLException if a database access error occurs
1998     * @since 1.4
1999     */
2000    void updateArray(int columnIndex, java.sql.Array x) throws java.rmi.RemoteException , SQLException;
2001
2002    /**
2003     * Updates the designated column with a <code>java.sql.Array</code> value.
2004     * The updater methods are used to update column values in the
2005     * current row or the insert row. The updater methods do not
2006     * update the underlying database; instead the <code>updateRow</code> or
2007     * <code>insertRow</code> methods are called to update the database.
2008     *
2009     * @param columnName the name of the column
2010     * @param x the new column value
2011     * @exception SQLException if a database access error occurs
2012     * @since 1.4
2013     */
2014    void updateArray(String columnName, java.sql.Array x) throws java.rmi.RemoteException , SQLException;
2015};
2016
2017
2018

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags