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


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

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags