ResultSet


1   /*
2    * HA-JDBC: High-Availability JDBC
3    * Copyright (c) 2004-2006 Paul Ferraro
4    * 
5    * This library is free software; you can redistribute it and/or modify it 
6    * under the terms of the GNU Lesser General Public License as published by the 
7    * Free Software Foundation; either version 2.1 of the License, or (at your 
8    * option) any later version.
9    * 
10   * This library is distributed in the hope that it will be useful, but WITHOUT
11   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 
12   * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License 
13   * for more details.
14   * 
15   * You should have received a copy of the GNU Lesser General Public License
16   * along with this library; if not, write to the Free Software Foundation, 
17   * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18   * 
19   * Contact: ferraro@users.sourceforge.net
20   */
21  package net.sf.hajdbc.sql;
22  
23  import java.io.File  ;
24  import java.io.InputStream  ;
25  import java.io.Reader  ;
26  import java.math.BigDecimal  ;
27  import java.net.URL  ;
28  import java.sql.Array  ;
29  import java.sql.Blob  ;
30  import java.sql.Clob  ;
31  import java.sql.Date  ;
32  import java.sql.Ref  ;
33  import java.sql.ResultSetMetaData  ;
34  import java.sql.SQLException  ;
35  import java.sql.SQLWarning  ;
36  import java.sql.Time  ;
37  import java.sql.Timestamp  ;
38  import java.util.Calendar  ;
39  import java.util.Map  ;
40  
41  import net.sf.hajdbc.Database;
42  import net.sf.hajdbc.Operation;
43  
44  /**
45   * @author  Paul Ferraro
46   * @version $Revision: 1437 $
47   * @param <T> 
48   * @since   1.0
49   */
50  public class ResultSet<T extends java.sql.Statement  > extends SQLObject<java.sql.ResultSet  , T> implements java.sql.ResultSet  
51  {
52      /**
53       * Constructs a new ResultSetProxy.
54       * @param statement a Statement proxy
55       * @param operation an operation that creates ResultSets
56       * @throws SQLException if operation execution fails
57       */
58      public ResultSet(Statement<T> statement, Operation<T, java.sql.ResultSet  > operation) throws SQLException  
59      {
60          super(statement, operation, statement.getDatabaseCluster().getTransactionalExecutor(), statement.getDatabaseCluster().readLock());
61      }
62      
63      /**
64       * @see net.sf.hajdbc.sql.SQLObject#handleExceptions(java.util.Map)
65       */
66      @Override  
67      public void handleExceptions(Map  <Database, SQLException  > exceptionMap) throws SQLException  
68      {
69          this.parent.handleExceptions(exceptionMap);
70      }
71  
72      /**
73       * @see java.sql.ResultSet#absolute(int)
74       */
75      public boolean absolute(final int index) throws SQLException  
76      {
77          Operation<java.sql.ResultSet  , Boolean  > operation = new Operation<java.sql.ResultSet  , Boolean  >()
78          {
79              public Boolean   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
80              {
81                  return resultSet.absolute(index);
82              }
83          };
84          
85          return this.firstValue(this.executeWriteToDriver(operation));
86      }
87  
88      /**
89       * @see java.sql.ResultSet#afterLast()
90       */
91      public void afterLast() throws SQLException  
92      {
93          Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
94          {
95              public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
96              {
97                  resultSet.afterLast();
98                  
99                  return null;
100             }
101         };
102         
103         this.executeWriteToDriver(operation);
104     }
105 
106     /**
107      * @see java.sql.ResultSet#beforeFirst()
108      */
109     public void beforeFirst() throws SQLException  
110     {
111         Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
112         {
113             public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
114             {
115                 resultSet.beforeFirst();
116                 
117                 return null;
118             }
119         };
120         
121         this.executeWriteToDriver(operation);
122     }
123 
124     /**
125      * @see java.sql.ResultSet#cancelRowUpdates()
126      */
127     public void cancelRowUpdates() throws SQLException  
128     {
129         Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
130         {
131             public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
132             {
133                 resultSet.cancelRowUpdates();
134                 
135                 return null;
136             }
137         };
138         
139         this.executeWriteToDriver(operation);
140     }
141 
142     /**
143      * @see java.sql.ResultSet#clearWarnings()
144      */
145     public void clearWarnings() throws SQLException  
146     {
147         Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
148         {
149             public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
150             {
151                 resultSet.clearWarnings();
152                 
153                 return null;
154             }
155         };
156         
157         this.executeWriteToDriver(operation);
158     }
159 
160     /**
161      * @see java.sql.ResultSet#close()
162      */
163     public void close() throws SQLException  
164     {
165         Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
166         {
167             public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
168             {
169                 resultSet.close();
170                 
171                 return null;
172             }
173         };
174         
175         this.executeNonTransactionalWriteToDatabase(operation);
176     }
177 
178     /**
179      * @see java.sql.ResultSet#deleteRow()
180      */
181     public void deleteRow() throws SQLException  
182     {
183         Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
184         {
185             public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
186             {
187                 resultSet.deleteRow();
188                 
189                 return null;
190             }
191         };
192         
193         this.executeTransactionalWriteToDatabase(operation);
194     }
195 
196     /**
197      * @see java.sql.ResultSet#findColumn(java.lang.String)
198      */
199     public int findColumn(final String   name) throws SQLException  
200     {
201         Operation<java.sql.ResultSet  , Integer  > operation = new Operation<java.sql.ResultSet  , Integer  >()
202         {
203             public Integer   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
204             {
205                 return resultSet.findColumn(name);
206             }
207         };
208 
209         return this.executeReadFromDriver(operation);
210     }
211 
212     /**
213      * @see java.sql.ResultSet#first()
214      */
215     public boolean first() throws SQLException  
216     {
217         Operation<java.sql.ResultSet  , Boolean  > operation = new Operation<java.sql.ResultSet  , Boolean  >()
218         {
219             public Boolean   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
220             {
221                 return resultSet.first();
222             }
223         };
224         
225         return this.firstValue((this.getType() == java.sql.ResultSet.TYPE_SCROLL_SENSITIVE) ? this.executeNonTransactionalWriteToDatabase(operation) : this.executeWriteToDriver(operation));
226     }
227 
228     /**
229      * @see java.sql.ResultSet#getArray(int)
230      */
231     public Array   getArray(final int index) throws SQLException  
232     {
233         Operation<java.sql.ResultSet  , Array  > operation = new Operation<java.sql.ResultSet  , Array  >()
234         {
235             public Array   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
236             {
237                 return resultSet.getArray(index);
238             }
239         };
240         
241         return this.executeReadFromDriver(operation);
242     }
243 
244     /**
245      * @see java.sql.ResultSet#getArray(java.lang.String)
246      */
247     public Array   getArray(final String   name) throws SQLException  
248     {
249         Operation<java.sql.ResultSet  , Array  > operation = new Operation<java.sql.ResultSet  , Array  >()
250         {
251             public Array   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
252             {
253                 return resultSet.getArray(name);
254             }
255         };
256         
257         return this.executeReadFromDriver(operation);
258     }
259 
260     /**
261      * @see java.sql.ResultSet#getAsciiStream(int)
262      */
263     public InputStream   getAsciiStream(final int index) throws SQLException  
264     {
265         Operation<java.sql.ResultSet  , InputStream  > operation = new Operation<java.sql.ResultSet  , InputStream  >()
266         {
267             public InputStream   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
268             {
269                 return resultSet.getAsciiStream(index);
270             }
271         };
272         
273         return this.executeReadFromDriver(operation);
274     }
275 
276     /**
277      * @see java.sql.ResultSet#getAsciiStream(java.lang.String)
278      */
279     public InputStream   getAsciiStream(final String   name) throws SQLException  
280     {
281         Operation<java.sql.ResultSet  , InputStream  > operation = new Operation<java.sql.ResultSet  , InputStream  >()
282         {
283             public InputStream   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
284             {
285                 return resultSet.getAsciiStream(name);
286             }
287         };
288         
289         return this.executeReadFromDriver(operation);
290     }
291 
292     /**
293      * @see java.sql.ResultSet#getBigDecimal(int)
294      */
295     public BigDecimal   getBigDecimal(final int index) throws SQLException  
296     {
297         Operation<java.sql.ResultSet  , BigDecimal  > operation = new Operation<java.sql.ResultSet  , BigDecimal  >()
298         {
299             public BigDecimal   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
300             {
301                 return resultSet.getBigDecimal(index);
302             }
303         };
304         
305         return this.executeReadFromDriver(operation);
306     }
307 
308     /**
309      * @see java.sql.ResultSet#getBigDecimal(int, int)
310      * @deprecated
311      */
312     @Deprecated  
313     public BigDecimal   getBigDecimal(final int index, final int scale) throws SQLException  
314     {
315         Operation<java.sql.ResultSet  , BigDecimal  > operation = new Operation<java.sql.ResultSet  , BigDecimal  >()
316         {
317             public BigDecimal   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
318             {
319                 return resultSet.getBigDecimal(index, scale);
320             }
321         };
322         
323         return this.executeReadFromDriver(operation);
324     }
325 
326     /**
327      * @see java.sql.ResultSet#getBigDecimal(java.lang.String)
328      */
329     public BigDecimal   getBigDecimal(final String   name) throws SQLException  
330     {
331         Operation<java.sql.ResultSet  , BigDecimal  > operation = new Operation<java.sql.ResultSet  , BigDecimal  >()
332         {
333             public BigDecimal   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
334             {
335                 return resultSet.getBigDecimal(name);
336             }
337         };
338         
339         return this.executeReadFromDriver(operation);
340     }
341 
342     /**
343      * @see java.sql.ResultSet#getBigDecimal(java.lang.String, int)
344      * @deprecated
345      */
346     @Deprecated  
347     public BigDecimal   getBigDecimal(final String   name, final int scale) throws SQLException  
348     {
349         Operation<java.sql.ResultSet  , BigDecimal  > operation = new Operation<java.sql.ResultSet  , BigDecimal  >()
350         {
351             public BigDecimal   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
352             {
353                 return resultSet.getBigDecimal(name, scale);
354             }
355         };
356         
357         return this.executeReadFromDriver(operation);
358     }
359 
360     /**
361      * @see java.sql.ResultSet#getBinaryStream(int)
362      */
363     public InputStream   getBinaryStream(final int index) throws SQLException  
364     {
365         Operation<java.sql.ResultSet  , InputStream  > operation = new Operation<java.sql.ResultSet  , InputStream  >()
366         {
367             public InputStream   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
368             {
369                 return resultSet.getBinaryStream(index);
370             }
371         };
372         
373         return this.executeReadFromDriver(operation);
374     }
375 
376     /**
377      * @see java.sql.ResultSet#getBinaryStream(java.lang.String)
378      */
379     public InputStream   getBinaryStream(final String   name) throws SQLException  
380     {
381         Operation<java.sql.ResultSet  , InputStream  > operation = new Operation<java.sql.ResultSet  , InputStream  >()
382         {
383             public InputStream   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
384             {
385                 return resultSet.getBinaryStream(name);
386             }
387         };
388         
389         return this.executeReadFromDriver(operation);
390     }
391 
392     /**
393      * @see java.sql.ResultSet#getBlob(int)
394      */
395     public Blob   getBlob(final int index) throws SQLException  
396     {
397         Operation<java.sql.ResultSet  , java.sql.Blob  > operation = new Operation<java.sql.ResultSet  , Blob  >()
398         {
399             public Blob   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
400             {
401                 return resultSet.getBlob(index);
402             }
403         };
404         
405         return this.executeReadFromDriver(operation);
406     }
407 
408     /**
409      * @see java.sql.ResultSet#getBlob(java.lang.String)
410      */
411     public Blob   getBlob(final String   name) throws SQLException  
412     {
413         Operation<java.sql.ResultSet  , java.sql.Blob  > operation = new Operation<java.sql.ResultSet  , Blob  >()
414         {
415             public Blob   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
416             {
417                 return resultSet.getBlob(name);
418             }
419         };
420         
421         return this.executeReadFromDriver(operation);
422     }
423 
424     /**
425      * @see java.sql.ResultSet#getBoolean(int)
426      */
427     public boolean getBoolean(final int index) throws SQLException  
428     {
429         Operation<java.sql.ResultSet  , Boolean  > operation = new Operation<java.sql.ResultSet  , Boolean  >()
430         {
431             public Boolean   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
432             {
433                 return resultSet.getBoolean(index);
434             }
435         };
436         
437         return this.executeReadFromDriver(operation);
438     }
439 
440     /**
441      * @see java.sql.ResultSet#getBoolean(java.lang.String)
442      */
443     public boolean getBoolean(final String   name) throws SQLException  
444     {
445         Operation<java.sql.ResultSet  , Boolean  > operation = new Operation<java.sql.ResultSet  , Boolean  >()
446         {
447             public Boolean   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
448             {
449                 return resultSet.getBoolean(name);
450             }
451         };
452         
453         return this.executeReadFromDriver(operation);
454     }
455 
456     /**
457      * @see java.sql.ResultSet#getByte(int)
458      */
459     public byte getByte(final int index) throws SQLException  
460     {
461         Operation<java.sql.ResultSet  , Byte  > operation = new Operation<java.sql.ResultSet  , Byte  >()
462         {
463             public Byte   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
464             {
465                 return resultSet.getByte(index);
466             }
467         };
468         
469         return this.executeReadFromDriver(operation);
470     }
471 
472     /**
473      * @see java.sql.ResultSet#getByte(java.lang.String)
474      */
475     public byte getByte(final String   name) throws SQLException  
476     {
477         Operation<java.sql.ResultSet  , Byte  > operation = new Operation<java.sql.ResultSet  , Byte  >()
478         {
479             public Byte   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
480             {
481                 return resultSet.getByte(name);
482             }
483         };
484         
485         return this.executeReadFromDriver(operation);
486     }
487 
488     /**
489      * @see java.sql.ResultSet#getBytes(int)
490      */
491     public byte[] getBytes(final int index) throws SQLException  
492     {
493         Operation<java.sql.ResultSet  , byte[]> operation = new Operation<java.sql.ResultSet  , byte[]>()
494         {
495             public byte[] execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
496             {
497                 return resultSet.getBytes(index);
498             }
499         };
500         
501         return this.executeReadFromDriver(operation);
502     }
503 
504     /**
505      * @see java.sql.ResultSet#getBytes(java.lang.String)
506      */
507     public byte[] getBytes(final String   name) throws SQLException  
508     {
509         Operation<java.sql.ResultSet  , byte[]> operation = new Operation<java.sql.ResultSet  , byte[]>()
510         {
511             public byte[] execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
512             {
513                 return resultSet.getBytes(name);
514             }
515         };
516         
517         return this.executeReadFromDriver(operation);
518     }
519 
520     /**
521      * @see java.sql.ResultSet#getCharacterStream(int)
522      */
523     public Reader   getCharacterStream(final int index) throws SQLException  
524     {
525         Operation<java.sql.ResultSet  , Reader  > operation = new Operation<java.sql.ResultSet  , Reader  >()
526         {
527             public Reader   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
528             {
529                 return resultSet.getCharacterStream(index);
530             }
531         };
532         
533         return this.executeReadFromDriver(operation);
534     }
535 
536     /**
537      * @see java.sql.ResultSet#getCharacterStream(java.lang.String)
538      */
539     public Reader   getCharacterStream(final String   name) throws SQLException  
540     {
541         Operation<java.sql.ResultSet  , Reader  > operation = new Operation<java.sql.ResultSet  , Reader  >()
542         {
543             public Reader   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
544             {
545                 return resultSet.getCharacterStream(name);
546             }
547         };
548         
549         return this.executeReadFromDriver(operation);
550     }
551 
552     /**
553      * @see java.sql.ResultSet#getClob(int)
554      */
555     public Clob   getClob(final int index) throws SQLException  
556     {
557         Operation<java.sql.ResultSet  , Clob  > operation = new Operation<java.sql.ResultSet  , Clob  >()
558         {
559             public Clob   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
560             {
561                 return resultSet.getClob(index);
562             }
563         };
564         
565         return this.executeReadFromDriver(operation);
566     }
567 
568     /**
569      * @see java.sql.ResultSet#getClob(java.lang.String)
570      */
571     public Clob   getClob(final String   name) throws SQLException  
572     {
573         Operation<java.sql.ResultSet  , Clob  > operation = new Operation<java.sql.ResultSet  , Clob  >()
574         {
575             public Clob   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
576             {
577                 return resultSet.getClob(name);
578             }
579         };
580         
581         return this.executeReadFromDriver(operation);
582     }
583 
584     /**
585      * @see java.sql.ResultSet#getConcurrency()
586      */
587     public int getConcurrency() throws SQLException  
588     {
589         Operation<java.sql.ResultSet  , Integer  > operation = new Operation<java.sql.ResultSet  , Integer  >()
590         {
591             public Integer   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
592             {
593                 return resultSet.getConcurrency();
594             }
595         };
596         
597         return this.executeReadFromDriver(operation);
598     }
599 
600     /**
601      * @see java.sql.ResultSet#getCursorName()
602      */
603     public String   getCursorName() throws SQLException  
604     {
605         Operation<java.sql.ResultSet  , String  > operation = new Operation<java.sql.ResultSet  , String  >()
606         {
607             public String   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
608             {
609                 return resultSet.getCursorName();
610             }
611         };
612         
613         return this.executeReadFromDriver(operation);
614     }
615 
616     /**
617      * @see java.sql.ResultSet#getDate(int)
618      */
619     public Date   getDate(final int index) throws SQLException  
620     {
621         Operation<java.sql.ResultSet  , Date  > operation = new Operation<java.sql.ResultSet  , Date  >()
622         {
623             public Date   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
624             {
625                 return resultSet.getDate(index);
626             }
627         };
628         
629         return this.executeReadFromDriver(operation);
630     }
631 
632     /**
633      * @see java.sql.ResultSet#getDate(int, java.util.Calendar)
634      */
635     public Date   getDate(final int index, final Calendar   calendar) throws SQLException  
636     {
637         Operation<java.sql.ResultSet  , Date  > operation = new Operation<java.sql.ResultSet  , Date  >()
638         {
639             public Date   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
640             {
641                 return resultSet.getDate(index, calendar);
642             }
643         };
644         
645         return this.executeReadFromDriver(operation);
646     }
647 
648     /**
649      * @see java.sql.ResultSet#getDate(java.lang.String)
650      */
651     public Date   getDate(final String   name) throws SQLException  
652     {
653         Operation<java.sql.ResultSet  , Date  > operation = new Operation<java.sql.ResultSet  , Date  >()
654         {
655             public Date   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
656             {
657                 return resultSet.getDate(name);
658             }
659         };
660         
661         return this.executeReadFromDriver(operation);
662     }
663 
664     /**
665      * @see java.sql.ResultSet#getDate(java.lang.String, java.util.Calendar)
666      */
667     public Date   getDate(final String   name, final Calendar   calendar) throws SQLException  
668     {
669         Operation<java.sql.ResultSet  , Date  > operation = new Operation<java.sql.ResultSet  , Date  >()
670         {
671             public Date   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
672             {
673                 return resultSet.getDate(name, calendar);
674             }
675         };
676         
677         return this.executeReadFromDriver(operation);
678     }
679 
680     /**
681      * @see java.sql.ResultSet#getDouble(int)
682      */
683     public double getDouble(final int index) throws SQLException  
684     {
685         Operation<java.sql.ResultSet  , Double  > operation = new Operation<java.sql.ResultSet  , Double  >()
686         {
687             public Double   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
688             {
689                 return resultSet.getDouble(index);
690             }
691         };
692         
693         return this.executeReadFromDriver(operation);
694     }
695 
696     /**
697      * @see java.sql.ResultSet#getDouble(java.lang.String)
698      */
699     public double getDouble(final String   name) throws SQLException  
700     {
701         Operation<java.sql.ResultSet  , Double  > operation = new Operation<java.sql.ResultSet  , Double  >()
702         {
703             public Double   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
704             {
705                 return resultSet.getDouble(name);
706             }
707         };
708         
709         return this.executeReadFromDriver(operation);
710     }
711 
712     /**
713      * @see java.sql.ResultSet#getFetchDirection()
714      */
715     public int getFetchDirection() throws SQLException  
716     {
717         Operation<java.sql.ResultSet  , Integer  > operation = new Operation<java.sql.ResultSet  , Integer  >()
718         {
719             public Integer   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
720             {
721                 return resultSet.getFetchDirection();
722             }
723         };
724         
725         return this.executeReadFromDriver(operation);
726     }
727 
728     /**
729      * @see java.sql.ResultSet#getFetchSize()
730      */
731     public int getFetchSize() throws SQLException  
732     {
733         Operation<java.sql.ResultSet  , Integer  > operation = new Operation<java.sql.ResultSet  , Integer  >()
734         {
735             public Integer   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
736             {
737                 return resultSet.getFetchSize();
738             }
739         };
740         
741         return this.executeReadFromDriver(operation);
742     }
743 
744     /**
745      * @see java.sql.ResultSet#getFloat(int)
746      */
747     public float getFloat(final int index) throws SQLException  
748     {
749         Operation<java.sql.ResultSet  , Float  > operation = new Operation<java.sql.ResultSet  , Float  >()
750         {
751             public Float   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
752             {
753                 return resultSet.getFloat(index);
754             }
755         };
756         
757         return this.executeReadFromDriver(operation);
758     }
759 
760     /**
761      * @see java.sql.ResultSet#getFloat(java.lang.String)
762      */
763     public float getFloat(final String   name) throws SQLException  
764     {
765         Operation<java.sql.ResultSet  , Float  > operation = new Operation<java.sql.ResultSet  , Float  >()
766         {
767             public Float   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
768             {
769                 return resultSet.getFloat(name);
770             }
771         };
772         
773         return this.executeReadFromDriver(operation);
774     }
775 
776     /**
777      * @see java.sql.ResultSet#getInt(int)
778      */
779     public int getInt(final int index) throws SQLException  
780     {
781         Operation<java.sql.ResultSet  , Integer  > operation = new Operation<java.sql.ResultSet  , Integer  >()
782         {
783             public Integer   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
784             {
785                 return resultSet.getInt(index);
786             }
787         };
788         
789         return this.executeReadFromDriver(operation);
790     }
791 
792     /**
793      * @see java.sql.ResultSet#getInt(java.lang.String)
794      */
795     public int getInt(final String   name) throws SQLException  
796     {
797         Operation<java.sql.ResultSet  , Integer  > operation = new Operation<java.sql.ResultSet  , Integer  >()
798         {
799             public Integer   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
800             {
801                 return resultSet.getInt(name);
802             }
803         };
804         
805         return this.executeReadFromDriver(operation);
806     }
807 
808     /**
809      * @see java.sql.ResultSet#getLong(int)
810      */
811     public long getLong(final int index) throws SQLException  
812     {
813         Operation<java.sql.ResultSet  , Long  > operation = new Operation<java.sql.ResultSet  , Long  >()
814         {
815             public Long   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
816             {
817                 return resultSet.getLong(index);
818             }
819         };
820         
821         return this.executeReadFromDriver(operation);
822     }
823 
824     /**
825      * @see java.sql.ResultSet#getLong(java.lang.String)
826      */
827     public long getLong(final String   name) throws SQLException  
828     {
829         Operation<java.sql.ResultSet  , Long  > operation = new Operation<java.sql.ResultSet  , Long  >()
830         {
831             public Long   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
832             {
833                 return resultSet.getLong(name);
834             }
835         };
836         
837         return this.executeReadFromDriver(operation);
838     }
839 
840     /**
841      * @see java.sql.ResultSet#getMetaData()
842      */
843     public ResultSetMetaData   getMetaData() throws SQLException  
844     {
845         Operation<java.sql.ResultSet  , ResultSetMetaData  > operation = new Operation<java.sql.ResultSet  , ResultSetMetaData  >()
846         {
847             public ResultSetMetaData   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
848             {
849                 return resultSet.getMetaData();
850             }
851         };
852         
853         return this.executeReadFromDriver(operation);
854     }
855 
856     /**
857      * @see java.sql.ResultSet#getObject(int)
858      */
859     public Object   getObject(final int index) throws SQLException  
860     {
861         Operation<java.sql.ResultSet  , Object  > operation = new Operation<java.sql.ResultSet  , Object  >()
862         {
863             public Object   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
864             {
865                 return resultSet.getObject(index);
866             }
867         };
868         
869         return this.executeReadFromDriver(operation);
870     }
871 
872     /**
873      * @see java.sql.ResultSet#getObject(int, java.util.Map)
874      */
875     public Object   getObject(final int index, final Map  <String  , Class  <?>> typeMap) throws SQLException  
876     {
877         Operation<java.sql.ResultSet  , Object  > operation = new Operation<java.sql.ResultSet  , Object  >()
878         {
879             public Object   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
880             {
881                 return resultSet.getObject(index, typeMap);
882             }
883         };
884         
885         return this.executeReadFromDriver(operation);
886     }
887 
888     /**
889      * @see java.sql.ResultSet#getObject(java.lang.String)
890      */
891     public Object   getObject(final String   name) throws SQLException  
892     {
893         Operation<java.sql.ResultSet  , Object  > operation = new Operation<java.sql.ResultSet  , Object  >()
894         {
895             public Object   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
896             {
897                 return resultSet.getObject(name);
898             }
899         };
900         
901         return this.executeReadFromDriver(operation);
902     }
903 
904     /**
905      * @see java.sql.ResultSet#getObject(java.lang.String, java.util.Map)
906      */
907     public Object   getObject(final String   name, final Map  <String  , Class  <?>> typeMap) throws SQLException  
908     {
909         Operation<java.sql.ResultSet  , Object  > operation = new Operation<java.sql.ResultSet  , Object  >()
910         {
911             public Object   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
912             {
913                 return resultSet.getObject(name, typeMap);
914             }
915         };
916         
917         return this.executeReadFromDriver(operation);
918     }
919 
920     /**
921      * @see java.sql.ResultSet#getRef(int)
922      */
923     public Ref   getRef(final int index) throws SQLException  
924     {
925         Operation<java.sql.ResultSet  , Ref  > operation = new Operation<java.sql.ResultSet  , Ref  >()
926         {
927             public Ref   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
928             {
929                 return resultSet.getRef(index);
930             }
931         };
932         
933         return this.executeReadFromDriver(operation);
934     }
935 
936     /**
937      * @see java.sql.ResultSet#getRef(java.lang.String)
938      */
939     public Ref   getRef(final String   name) throws SQLException  
940     {
941         Operation<java.sql.ResultSet  , Ref  > operation = new Operation<java.sql.ResultSet  , Ref  >()
942         {
943             public Ref   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
944             {
945                 return resultSet.getRef(name);
946             }
947         };
948         
949         return this.executeReadFromDriver(operation);
950     }
951 
952     /**
953      * @see java.sql.ResultSet#getRow()
954      */
955     public int getRow() throws SQLException  
956     {
957         Operation<java.sql.ResultSet  , Integer  > operation = new Operation<java.sql.ResultSet  , Integer  >()
958         {
959             public Integer   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
960             {
961                 return resultSet.getRow();
962             }
963         };
964         
965         return this.executeReadFromDriver(operation);
966     }
967 
968     /**
969      * @see java.sql.ResultSet#getShort(int)
970      */
971     public short getShort(final int index) throws SQLException  
972     {
973         Operation<java.sql.ResultSet  , Short  > operation = new Operation<java.sql.ResultSet  , Short  >()
974         {
975             public Short   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
976             {
977                 return resultSet.getShort(index);
978             }
979         };
980         
981         return this.executeReadFromDriver(operation);
982     }
983 
984     /**
985      * @see java.sql.ResultSet#getShort(java.lang.String)
986      */
987     public short getShort(final String   name) throws SQLException  
988     {
989         Operation<java.sql.ResultSet  , Short  > operation = new Operation<java.sql.ResultSet  , Short  >()
990         {
991             public Short   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
992             {
993                 return resultSet.getShort(name);
994             }
995         };
996         
997         return this.executeReadFromDriver(operation);
998     }
999 
1000    /**
1001     * @see java.sql.ResultSet#getStatement()
1002     */
1003    public java.sql.Statement   getStatement()
1004    {
1005        return Statement.class.cast(this.parent);
1006    }
1007
1008    /**
1009     * @see java.sql.ResultSet#getString(int)
1010     */
1011    public String   getString(final int index) throws SQLException  
1012    {
1013        Operation<java.sql.ResultSet  , String  > operation = new Operation<java.sql.ResultSet  , String  >()
1014        {
1015            public String   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1016            {
1017                return resultSet.getString(index);
1018            }
1019        };
1020        
1021        return this.executeReadFromDriver(operation);
1022    }
1023
1024    /**
1025     * @see java.sql.ResultSet#getString(java.lang.String)
1026     */
1027    public String   getString(final String   name) throws SQLException  
1028    {
1029        Operation<java.sql.ResultSet  , String  > operation = new Operation<java.sql.ResultSet  , String  >()
1030        {
1031            public String   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1032            {
1033                return resultSet.getString(name);
1034            }
1035        };
1036        
1037        return this.executeReadFromDriver(operation);
1038    }
1039
1040    /**
1041     * @see java.sql.ResultSet#getTime(int)
1042     */
1043    public Time   getTime(final int index) throws SQLException  
1044    {
1045        Operation<java.sql.ResultSet  , Time  > operation = new Operation<java.sql.ResultSet  , Time  >()
1046        {
1047            public Time   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1048            {
1049                return resultSet.getTime(index);
1050            }
1051        };
1052        
1053        return this.executeReadFromDriver(operation);
1054    }
1055
1056    /**
1057     * @see java.sql.ResultSet#getTime(int, java.util.Calendar)
1058     */
1059    public Time   getTime(final int index, final Calendar   calendar) throws SQLException  
1060    {
1061        Operation<java.sql.ResultSet  , Time  > operation = new Operation<java.sql.ResultSet  , Time  >()
1062        {
1063            public Time   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1064            {
1065                return resultSet.getTime(index, calendar);
1066            }
1067        };
1068        
1069        return this.executeReadFromDriver(operation);
1070    }
1071
1072    /**
1073     * @see java.sql.ResultSet#getTime(java.lang.String)
1074     */
1075    public Time   getTime(final String   name) throws SQLException  
1076    {
1077        Operation<java.sql.ResultSet  , Time  > operation = new Operation<java.sql.ResultSet  , Time  >()
1078        {
1079            public Time   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1080            {
1081                return resultSet.getTime(name);
1082            }
1083        };
1084        
1085        return this.executeReadFromDriver(operation);
1086    }
1087
1088    /**
1089     * @see java.sql.ResultSet#getTime(java.lang.String, java.util.Calendar)
1090     */
1091    public Time   getTime(final String   name, final Calendar   calendar) throws SQLException  
1092    {
1093        Operation<java.sql.ResultSet  , Time  > operation = new Operation<java.sql.ResultSet  , Time  >()
1094        {
1095            public Time   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1096            {
1097                return resultSet.getTime(name, calendar);
1098            }
1099        };
1100        
1101        return this.executeReadFromDriver(operation);
1102    }
1103
1104    /**
1105     * @see java.sql.ResultSet#getTimestamp(int)
1106     */
1107    public Timestamp   getTimestamp(final int index) throws SQLException  
1108    {
1109        Operation<java.sql.ResultSet  , Timestamp  > operation = new Operation<java.sql.ResultSet  , Timestamp  >()
1110        {
1111            public Timestamp   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1112            {
1113                return resultSet.getTimestamp(index);
1114            }
1115        };
1116        
1117        return this.executeReadFromDriver(operation);
1118    }
1119
1120    /**
1121     * @see java.sql.ResultSet#getTimestamp(int, java.util.Calendar)
1122     */
1123    public Timestamp   getTimestamp(final int index, final Calendar   calendar) throws SQLException  
1124    {
1125        Operation<java.sql.ResultSet  , Timestamp  > operation = new Operation<java.sql.ResultSet  , Timestamp  >()
1126        {
1127            public Timestamp   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1128            {
1129                return resultSet.getTimestamp(index, calendar);
1130            }
1131        };
1132        
1133        return this.executeReadFromDriver(operation);
1134    }
1135
1136    /**
1137     * @see java.sql.ResultSet#getTimestamp(java.lang.String)
1138     */
1139    public Timestamp   getTimestamp(final String   name) throws SQLException  
1140    {
1141        Operation<java.sql.ResultSet  , Timestamp  > operation = new Operation<java.sql.ResultSet  , Timestamp  >()
1142        {
1143            public Timestamp   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1144            {
1145                return resultSet.getTimestamp(name);
1146            }
1147        };
1148        
1149        return this.executeReadFromDriver(operation);
1150    }
1151
1152    /**
1153     * @see java.sql.ResultSet#getTimestamp(java.lang.String, java.util.Calendar)
1154     */
1155    public Timestamp   getTimestamp(final String   name, final Calendar   calendar) throws SQLException  
1156    {
1157        Operation<java.sql.ResultSet  , Timestamp  > operation = new Operation<java.sql.ResultSet  , Timestamp  >()
1158        {
1159            public Timestamp   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1160            {
1161                return resultSet.getTimestamp(name, calendar);
1162            }
1163        };
1164        
1165        return this.executeReadFromDriver(operation);
1166    }
1167
1168    /**
1169     * @see java.sql.ResultSet#getType()
1170     */
1171    public int getType() throws SQLException  
1172    {
1173        Operation<java.sql.ResultSet  , Integer  > operation = new Operation<java.sql.ResultSet  , Integer  >()
1174        {
1175            public Integer   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1176            {
1177                return resultSet.getType();
1178            }
1179        };
1180        
1181        return this.executeReadFromDriver(operation);
1182    }
1183
1184    /**
1185     * @see java.sql.ResultSet#getUnicodeStream(int)
1186     * @deprecated
1187     */
1188    @Deprecated  
1189    public InputStream   getUnicodeStream(final int index) throws SQLException  
1190    {
1191        Operation<java.sql.ResultSet  , InputStream  > operation = new Operation<java.sql.ResultSet  , InputStream  >()
1192        {
1193            public InputStream   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1194            {
1195                return resultSet.getUnicodeStream(index);
1196            }
1197        };
1198        
1199        return this.executeReadFromDriver(operation);
1200    }
1201
1202    /**
1203     * @see java.sql.ResultSet#getUnicodeStream(java.lang.String)
1204     * @deprecated
1205     */
1206    @Deprecated  
1207    public InputStream   getUnicodeStream(final String   name) throws SQLException  
1208    {
1209        Operation<java.sql.ResultSet  , InputStream  > operation = new Operation<java.sql.ResultSet  , InputStream  >()
1210        {
1211            public InputStream   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1212            {
1213                return resultSet.getUnicodeStream(name);
1214            }
1215        };
1216        
1217        return this.executeReadFromDriver(operation);
1218    }
1219
1220    /**
1221     * @see java.sql.ResultSet#getURL(int)
1222     */
1223    public URL   getURL(final int index) throws SQLException  
1224    {
1225        Operation<java.sql.ResultSet  , URL  > operation = new Operation<java.sql.ResultSet  , URL  >()
1226        {
1227            public URL   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1228            {
1229                return resultSet.getURL(index);
1230            }
1231        };
1232        
1233        return this.executeReadFromDriver(operation);
1234    }
1235
1236    /**
1237     * @see java.sql.ResultSet#getURL(java.lang.String)
1238     */
1239    public URL   getURL(final String   name) throws SQLException  
1240    {
1241        Operation<java.sql.ResultSet  , URL  > operation = new Operation<java.sql.ResultSet  , URL  >()
1242        {
1243            public URL   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1244            {
1245                return resultSet.getURL(name);
1246            }
1247        };
1248        
1249        return this.executeReadFromDriver(operation);
1250    }
1251
1252    /**
1253     * @see java.sql.ResultSet#getWarnings()
1254     */
1255    public SQLWarning   getWarnings() throws SQLException  
1256    {
1257        Operation<java.sql.ResultSet  , SQLWarning  > operation = new Operation<java.sql.ResultSet  , SQLWarning  >()
1258        {
1259            public SQLWarning   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1260            {
1261                return resultSet.getWarnings();
1262            }
1263        };
1264        
1265        return this.executeReadFromDriver(operation);
1266    }
1267
1268    /**
1269     * @see java.sql.ResultSet#insertRow()
1270     */
1271    public void insertRow() throws SQLException  
1272    {
1273        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1274        {
1275            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1276            {
1277                resultSet.insertRow();
1278                
1279                return null;
1280            }
1281        };
1282        
1283        this.executeTransactionalWriteToDatabase(operation);
1284    }
1285
1286    /**
1287     * @see java.sql.ResultSet#isAfterLast()
1288     */
1289    public boolean isAfterLast() throws SQLException  
1290    {
1291        Operation<java.sql.ResultSet  , Boolean  > operation = new Operation<java.sql.ResultSet  , Boolean  >()
1292        {
1293            public Boolean   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1294            {
1295                return resultSet.isAfterLast();
1296            }
1297        };
1298        
1299        return this.executeReadFromDriver(operation);
1300    }
1301
1302    /**
1303     * @see java.sql.ResultSet#isBeforeFirst()
1304     */
1305    public boolean isBeforeFirst() throws SQLException  
1306    {
1307        Operation<java.sql.ResultSet  , Boolean  > operation = new Operation<java.sql.ResultSet  , Boolean  >()
1308        {
1309            public Boolean   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1310            {
1311                return resultSet.isBeforeFirst();
1312            }
1313        };
1314        
1315        return this.executeReadFromDriver(operation);
1316    }
1317
1318    /**
1319     * @see java.sql.ResultSet#isFirst()
1320     */
1321    public boolean isFirst() throws SQLException  
1322    {
1323        Operation<java.sql.ResultSet  , Boolean  > operation = new Operation<java.sql.ResultSet  , Boolean  >()
1324        {
1325            public Boolean   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1326            {
1327                return resultSet.isFirst();
1328            }
1329        };
1330        
1331        return (this.getType() == java.sql.ResultSet.TYPE_SCROLL_SENSITIVE) ? this.executeReadFromDatabase(operation) : this.executeReadFromDriver(operation);
1332    }
1333
1334    /**
1335     * @see java.sql.ResultSet#isLast()
1336     */
1337    public boolean isLast() throws SQLException  
1338    {
1339        Operation<java.sql.ResultSet  , Boolean  > operation = new Operation<java.sql.ResultSet  , Boolean  >()
1340        {
1341            public Boolean   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1342            {
1343                return resultSet.isLast();
1344            }
1345        };
1346        
1347        return (this.getType() == java.sql.ResultSet.TYPE_SCROLL_SENSITIVE) ? this.executeReadFromDatabase(operation) : this.executeReadFromDriver(operation);
1348    }
1349
1350    /**
1351     * @see java.sql.ResultSet#last()
1352     */
1353    public boolean last() throws SQLException  
1354    {
1355        Operation<java.sql.ResultSet  , Boolean  > operation = new Operation<java.sql.ResultSet  , Boolean  >()
1356        {
1357            public Boolean   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1358            {
1359                return resultSet.last();
1360            }
1361        };
1362        
1363        return this.firstValue((this.getType() == java.sql.ResultSet.TYPE_SCROLL_SENSITIVE) ? this.executeNonTransactionalWriteToDatabase(operation) : this.executeWriteToDriver(operation));
1364    }
1365
1366    /**
1367     * @see java.sql.ResultSet#moveToCurrentRow()
1368     */
1369    public void moveToCurrentRow() throws SQLException  
1370    {
1371        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1372        {
1373            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1374            {
1375                resultSet.moveToCurrentRow();
1376                
1377                return null;
1378            }
1379        };
1380        
1381        if (this.getType() == java.sql.ResultSet.TYPE_SCROLL_SENSITIVE)
1382        {
1383            this.executeNonTransactionalWriteToDatabase(operation);
1384        }
1385        else
1386        {
1387            this.executeWriteToDriver(operation);
1388        }
1389    }
1390
1391    /**
1392     * @see java.sql.ResultSet#moveToInsertRow()
1393     */
1394    public void moveToInsertRow() throws SQLException  
1395    {
1396        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1397        {
1398            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1399            {
1400                resultSet.moveToInsertRow();
1401                
1402                return null;
1403            }
1404        };
1405        
1406        this.executeWriteToDriver(operation);
1407    }
1408
1409    /**
1410     * @see java.sql.ResultSet#next()
1411     */
1412    public boolean next() throws SQLException  
1413    {
1414        Operation<java.sql.ResultSet  , Boolean  > operation = new Operation<java.sql.ResultSet  , Boolean  >()
1415        {
1416            public Boolean   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1417            {
1418                return resultSet.next();
1419            }
1420        };
1421        
1422        return this.firstValue((this.getType() == java.sql.ResultSet.TYPE_SCROLL_SENSITIVE) ? this.executeNonTransactionalWriteToDatabase(operation) : this.executeWriteToDriver(operation));
1423    }
1424
1425    /**
1426     * @see java.sql.ResultSet#previous()
1427     */
1428    public boolean previous() throws SQLException  
1429    {
1430        Operation<java.sql.ResultSet  , Boolean  > operation = new Operation<java.sql.ResultSet  , Boolean  >()
1431        {
1432            public Boolean   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1433            {
1434                return resultSet.previous();
1435            }
1436        };
1437        
1438        return this.firstValue((this.getType() == java.sql.ResultSet.TYPE_SCROLL_SENSITIVE) ? this.executeNonTransactionalWriteToDatabase(operation) : this.executeWriteToDriver(operation));
1439    }
1440
1441    /**
1442     * @see java.sql.ResultSet#refreshRow()
1443     */
1444    public void refreshRow() throws SQLException  
1445    {
1446        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1447        {
1448            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1449            {
1450                resultSet.refreshRow();
1451                
1452                return null;
1453            }
1454        };
1455        
1456        this.executeNonTransactionalWriteToDatabase(operation);
1457    }
1458
1459    /**
1460     * @see java.sql.ResultSet#relative(int)
1461     */
1462    public boolean relative(final int index) throws SQLException  
1463    {
1464        Operation<java.sql.ResultSet  , Boolean  > operation = new Operation<java.sql.ResultSet  , Boolean  >()
1465        {
1466            public Boolean   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1467            {
1468                return resultSet.relative(index);
1469            }
1470        };
1471        
1472        return this.firstValue(this.executeWriteToDriver(operation));
1473    }
1474
1475    /**
1476     * @see java.sql.ResultSet#rowDeleted()
1477     */
1478    public boolean rowDeleted() throws SQLException  
1479    {
1480        Operation<java.sql.ResultSet  , Boolean  > operation = new Operation<java.sql.ResultSet  , Boolean  >()
1481        {
1482            public Boolean   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1483            {
1484                return resultSet.rowDeleted();
1485            }
1486        };
1487        
1488        return this.executeReadFromDriver(operation);
1489    }
1490
1491    /**
1492     * @see java.sql.ResultSet#rowInserted()
1493     */
1494    public boolean rowInserted() throws SQLException  
1495    {
1496        Operation<java.sql.ResultSet  , Boolean  > operation = new Operation<java.sql.ResultSet  , Boolean  >()
1497        {
1498            public Boolean   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1499            {
1500                return resultSet.rowInserted();
1501            }
1502        };
1503        
1504        return this.executeReadFromDriver(operation);
1505    }
1506
1507    /**
1508     * @see java.sql.ResultSet#rowUpdated()
1509     */
1510    public boolean rowUpdated() throws SQLException  
1511    {
1512        Operation<java.sql.ResultSet  , Boolean  > operation = new Operation<java.sql.ResultSet  , Boolean  >()
1513        {
1514            public Boolean   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1515            {
1516                return resultSet.rowUpdated();
1517            }
1518        };
1519        
1520        return this.executeReadFromDriver(operation);
1521    }
1522
1523    /**
1524     * @see java.sql.ResultSet#setFetchDirection(int)
1525     */
1526    public void setFetchDirection(final int direction) throws SQLException  
1527    {
1528        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1529        {
1530            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1531            {
1532                resultSet.setFetchDirection(direction);
1533                
1534                return null;
1535            }
1536        };
1537        
1538        this.executeWriteToDriver(operation);
1539    }
1540
1541    /**
1542     * @see java.sql.ResultSet#setFetchSize(int)
1543     */
1544    public void setFetchSize(final int size) throws SQLException  
1545    {
1546        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1547        {
1548            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1549            {
1550                resultSet.setFetchSize(size);
1551                
1552                return null;
1553            }
1554        };
1555        
1556        this.executeWriteToDriver(operation);
1557    }
1558
1559    /**
1560     * @see java.sql.ResultSet#updateArray(int, java.sql.Array)
1561     */
1562    public void updateArray(final int index, final Array   value) throws SQLException  
1563    {
1564        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1565        {
1566            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1567            {
1568                resultSet.updateArray(index, value);
1569                
1570                return null;
1571            }
1572        };
1573        
1574        this.executeWriteToDriver(operation);
1575    }
1576
1577    /**
1578     * @see java.sql.ResultSet#updateArray(java.lang.String, java.sql.Array)
1579     */
1580    public void updateArray(final String   name, final Array   value) throws SQLException  
1581    {
1582        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1583        {
1584            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1585            {
1586                resultSet.updateArray(name, value);
1587                
1588                return null;
1589            }
1590        };
1591        
1592        this.executeWriteToDriver(operation);
1593    }
1594
1595    /**
1596     * @see java.sql.ResultSet#updateAsciiStream(int, java.io.InputStream, int)
1597     */
1598    public void updateAsciiStream(final int index, InputStream   inputStream, final int length) throws SQLException  
1599    {
1600        final FileSupport fileSupport = this.getFileSupport();
1601        final File   file = fileSupport.createFile(inputStream);
1602        
1603        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1604        {
1605            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1606            {
1607                resultSet.updateAsciiStream(index, fileSupport.getInputStream(file), length);
1608                
1609                return null;
1610            }
1611        };
1612        
1613        this.executeWriteToDriver(operation);
1614    }
1615
1616    /**
1617     * @see java.sql.ResultSet#updateAsciiStream(java.lang.String, java.io.InputStream, int)
1618     */
1619    public void updateAsciiStream(final String   name, InputStream   inputStream, final int length) throws SQLException  
1620    {
1621        final FileSupport fileSupport = this.getFileSupport();
1622        final File   file = fileSupport.createFile(inputStream);
1623        
1624        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1625        {
1626            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1627            {
1628                resultSet.updateAsciiStream(name, fileSupport.getInputStream(file), length);
1629                
1630                return null;
1631            }
1632        };
1633        
1634        this.executeWriteToDriver(operation);
1635    }
1636
1637    /**
1638     * @see java.sql.ResultSet#updateBigDecimal(int, java.math.BigDecimal)
1639     */
1640    public void updateBigDecimal(final int index, final BigDecimal   value) throws SQLException  
1641    {
1642        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1643        {
1644            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1645            {
1646                resultSet.updateBigDecimal(index, value);
1647                
1648                return null;
1649            }
1650        };
1651        
1652        this.executeWriteToDriver(operation);
1653    }
1654
1655    /**
1656     * @see java.sql.ResultSet#updateBigDecimal(java.lang.String, java.math.BigDecimal)
1657     */
1658    public void updateBigDecimal(final String   name, final BigDecimal   value) throws SQLException  
1659    {
1660        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1661        {
1662            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1663            {
1664                resultSet.updateBigDecimal(name, value);
1665                
1666                return null;
1667            }
1668        };
1669        
1670        this.executeWriteToDriver(operation);
1671    }
1672
1673    /**
1674     * @see java.sql.ResultSet#updateBinaryStream(int, java.io.InputStream, int)
1675     */
1676    public void updateBinaryStream(final int index, InputStream   inputStream, final int length) throws SQLException  
1677    {
1678        final FileSupport fileSupport = this.getFileSupport();
1679        final File   file = fileSupport.createFile(inputStream);
1680        
1681        try
1682        {
1683            Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1684            {
1685                public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1686                {
1687                    resultSet.updateBinaryStream(index, fileSupport.getInputStream(file), length);
1688                    
1689                    return null;
1690                }
1691            };
1692            
1693            this.executeWriteToDriver(operation);
1694        }
1695        finally
1696        {
1697            file.delete();
1698        }
1699    }
1700
1701    /**
1702     * @see java.sql.ResultSet#updateBinaryStream(java.lang.String, java.io.InputStream, int)
1703     */
1704    public void updateBinaryStream(final String   name, InputStream   inputStream, final int length) throws SQLException  
1705    {
1706        final FileSupport fileSupport = this.getFileSupport();
1707        final File   file = fileSupport.createFile(inputStream);
1708        
1709        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1710        {
1711            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1712            {
1713                resultSet.updateBinaryStream(name, fileSupport.getInputStream(file), length);
1714                
1715                return null;
1716            }
1717        };
1718        
1719        this.executeWriteToDriver(operation);
1720    }
1721
1722    /**
1723     * @see java.sql.ResultSet#updateBlob(int, java.sql.Blob)
1724     */
1725    public void updateBlob(final int index, final java.sql.Blob   value) throws SQLException  
1726    {
1727        final FileSupport fileSupport = this.getFileSupport();
1728        final File   file = fileSupport.createFile(value);
1729        
1730        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1731        {
1732            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1733            {
1734                resultSet.updateBlob(index, fileSupport.getBlob(file));
1735                
1736                return null;
1737            }
1738        };
1739        
1740        this.executeWriteToDriver(operation);
1741    }
1742
1743    /**
1744     * @see java.sql.ResultSet#updateBlob(java.lang.String, java.sql.Blob)
1745     */
1746    public void updateBlob(final String   name, final java.sql.Blob   value) throws SQLException  
1747    {
1748        final FileSupport fileSupport = this.getFileSupport();
1749        final File   file = fileSupport.createFile(value);
1750        
1751        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1752        {
1753            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1754            {
1755                resultSet.updateBlob(name, fileSupport.getBlob(file));
1756                
1757                return null;
1758            }
1759        };
1760        
1761        this.executeWriteToDriver(operation);
1762    }
1763
1764    /**
1765     * @see java.sql.ResultSet#updateBoolean(int, boolean)
1766     */
1767    public void updateBoolean(final int index, final boolean value) throws SQLException  
1768    {
1769        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1770        {
1771            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1772            {
1773                resultSet.updateBoolean(index, value);
1774                
1775                return null;
1776            }
1777        };
1778        
1779        this.executeWriteToDriver(operation);
1780    }
1781
1782    /**
1783     * @see java.sql.ResultSet#updateBoolean(java.lang.String, boolean)
1784     */
1785    public void updateBoolean(final String   name, final boolean value) throws SQLException  
1786    {
1787        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1788        {
1789            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1790            {
1791                resultSet.updateBoolean(name, value);
1792                
1793                return null;
1794            }
1795        };
1796        
1797        this.executeWriteToDriver(operation);
1798    }
1799
1800    /**
1801     * @see java.sql.ResultSet#updateByte(int, byte)
1802     */
1803    public void updateByte(final int index, final byte value) throws SQLException  
1804    {
1805        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1806        {
1807            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1808            {
1809                resultSet.updateByte(index, value);
1810                
1811                return null;
1812            }
1813        };
1814        
1815        this.executeWriteToDriver(operation);
1816    }
1817
1818    /**
1819     * @see java.sql.ResultSet#updateByte(java.lang.String, byte)
1820     */
1821    public void updateByte(final String   name, final byte value) throws SQLException  
1822    {
1823        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1824        {
1825            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1826            {
1827                resultSet.updateByte(name, value);
1828                
1829                return null;
1830            }
1831        };
1832        
1833        this.executeWriteToDriver(operation);
1834    }
1835
1836    /**
1837     * @see java.sql.ResultSet#updateBytes(int, byte[])
1838     */
1839    public void updateBytes(final int index, final byte[] value) throws SQLException  
1840    {
1841        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1842        {
1843            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1844            {
1845                resultSet.updateBytes(index, value);
1846                
1847                return null;
1848            }
1849        };
1850        
1851        this.executeWriteToDriver(operation);
1852    }
1853
1854    /**
1855     * @see java.sql.ResultSet#updateBytes(java.lang.String, byte[])
1856     */
1857    public void updateBytes(final String   name, final byte[] value) throws SQLException  
1858    {
1859        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1860        {
1861            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1862            {
1863                resultSet.updateBytes(name, value);
1864                
1865                return null;
1866            }
1867        };
1868        
1869        this.executeWriteToDriver(operation);
1870    }
1871
1872    /**
1873     * @see java.sql.ResultSet#updateCharacterStream(int, java.io.Reader, int)
1874     */
1875    public void updateCharacterStream(final int index, Reader   reader, final int length) throws SQLException  
1876    {
1877        final FileSupport fileSupport = this.getFileSupport();
1878        final File   file = fileSupport.createFile(reader);
1879        
1880        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1881        {
1882            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1883            {
1884                resultSet.updateCharacterStream(index, fileSupport.getReader(file), length);
1885                
1886                return null;
1887            }
1888        };
1889        
1890        this.executeWriteToDriver(operation);
1891    }
1892
1893    /**
1894     * @see java.sql.ResultSet#updateCharacterStream(java.lang.String, java.io.Reader, int)
1895     */
1896    public void updateCharacterStream(final String   name, Reader   reader, final int length) throws SQLException  
1897    {
1898        final FileSupport fileSupport = this.getFileSupport();
1899        final File   file = fileSupport.createFile(reader);
1900        
1901        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1902        {
1903            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1904            {
1905                resultSet.updateCharacterStream(name, fileSupport.getReader(file), length);
1906                
1907                return null;
1908            }
1909        };
1910        
1911        this.executeWriteToDriver(operation);
1912    }
1913
1914    /**
1915     * @see java.sql.ResultSet#updateClob(int, java.sql.Clob)
1916     */
1917    public void updateClob(final int index, final java.sql.Clob   value) throws SQLException  
1918    {
1919        final FileSupport fileSupport = this.getFileSupport();
1920        final File   file = fileSupport.createFile(value);
1921        
1922        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1923        {
1924            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1925            {
1926                resultSet.updateClob(index, fileSupport.getClob(file));
1927                
1928                return null;
1929            }
1930        };
1931        
1932        this.executeWriteToDriver(operation);
1933    }
1934
1935    /**
1936     * @see java.sql.ResultSet#updateClob(java.lang.String, java.sql.Clob)
1937     */
1938    public void updateClob(final String   name, final java.sql.Clob   value) throws SQLException  
1939    {
1940        final FileSupport fileSupport = this.getFileSupport();
1941        final File   file = fileSupport.createFile(value);
1942        
1943        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1944        {
1945            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1946            {
1947                resultSet.updateClob(name, fileSupport.getClob(file));
1948                
1949                return null;
1950            }
1951        };
1952        
1953        this.executeWriteToDriver(operation);
1954    }
1955
1956    /**
1957     * @see java.sql.ResultSet#updateDate(int, java.sql.Date)
1958     */
1959    public void updateDate(final int index, final Date   value) throws SQLException  
1960    {
1961        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1962        {
1963            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1964            {
1965                resultSet.updateDate(index, value);
1966                
1967                return null;
1968            }
1969        };
1970        
1971        this.executeWriteToDriver(operation);
1972    }
1973
1974    /**
1975     * @see java.sql.ResultSet#updateDate(java.lang.String, java.sql.Date)
1976     */
1977    public void updateDate(final String   name, final Date   value) throws SQLException  
1978    {
1979        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1980        {
1981            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
1982            {
1983                resultSet.updateDate(name, value);
1984                
1985                return null;
1986            }
1987        };
1988        
1989        this.executeWriteToDriver(operation);
1990    }
1991
1992    /**
1993     * @see java.sql.ResultSet#updateDouble(int, double)
1994     */
1995    public void updateDouble(final int index, final double value) throws SQLException  
1996    {
1997        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
1998        {
1999            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
2000            {
2001                resultSet.updateDouble(index, value);
2002                
2003                return null;
2004            }
2005        };
2006        
2007        this.executeWriteToDriver(operation);
2008    }
2009
2010    /**
2011     * @see java.sql.ResultSet#updateDouble(java.lang.String, double)
2012     */
2013    public void updateDouble(final String   name, final double value) throws SQLException  
2014    {
2015        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
2016        {
2017            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
2018            {
2019                resultSet.updateDouble(name, value);
2020                
2021                return null;
2022            }
2023        };
2024        
2025        this.executeWriteToDriver(operation);
2026    }
2027
2028    /**
2029     * @see java.sql.ResultSet#updateFloat(int, float)
2030     */
2031    public void updateFloat(final int index, final float value) throws SQLException  
2032    {
2033        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
2034        {
2035            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
2036            {
2037                resultSet.updateFloat(index, value);
2038                
2039                return null;
2040            }
2041        };
2042        
2043        this.executeWriteToDriver(operation);
2044    }
2045
2046    /**
2047     * @see java.sql.ResultSet#updateFloat(java.lang.String, float)
2048     */
2049    public void updateFloat(final String   name, final float value) throws SQLException  
2050    {
2051        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
2052        {
2053            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
2054            {
2055                resultSet.updateFloat(name, value);
2056                
2057                return null;
2058            }
2059        };
2060        
2061        this.executeWriteToDriver(operation);
2062    }
2063
2064    /**
2065     * @see java.sql.ResultSet#updateInt(int, int)
2066     */
2067    public void updateInt(final int index, final int value) throws SQLException  
2068    {
2069        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
2070        {
2071            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
2072            {
2073                resultSet.updateInt(index, value);
2074                
2075                return null;
2076            }
2077        };
2078        
2079        this.executeWriteToDriver(operation);
2080    }
2081
2082    /**
2083     * @see java.sql.ResultSet#updateInt(java.lang.String, int)
2084     */
2085    public void updateInt(final String   name, final int value) throws SQLException  
2086    {
2087        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
2088        {
2089            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
2090            {
2091                resultSet.updateInt(name, value);
2092                
2093                return null;
2094            }
2095        };
2096        
2097        this.executeWriteToDriver(operation);
2098    }
2099
2100    /**
2101     * @see java.sql.ResultSet#updateLong(int, long)
2102     */
2103    public void updateLong(final int index, final long value) throws SQLException  
2104    {
2105        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
2106        {
2107            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
2108            {
2109                resultSet.updateLong(index, value);
2110                
2111                return null;
2112            }
2113        };
2114        
2115        this.executeWriteToDriver(operation);
2116    }
2117
2118    /**
2119     * @see java.sql.ResultSet#updateLong(java.lang.String, long)
2120     */
2121    public void updateLong(final String   name, final long value) throws SQLException  
2122    {
2123        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
2124        {
2125            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
2126            {
2127                resultSet.updateLong(name, value);
2128                
2129                return null;
2130            }
2131        };
2132        
2133        this.executeWriteToDriver(operation);
2134    }
2135
2136    /**
2137     * @see java.sql.ResultSet#updateNull(int)
2138     */
2139    public void updateNull(final int index) throws SQLException  
2140    {
2141        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
2142        {
2143            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
2144            {
2145                resultSet.updateNull(index);
2146                
2147                return null;
2148            }
2149        };
2150        
2151        this.executeWriteToDriver(operation);
2152    }
2153
2154    /**
2155     * @see java.sql.ResultSet#updateNull(java.lang.String)
2156     */
2157    public void updateNull(final String   name) throws SQLException  
2158    {
2159        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
2160        {
2161            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
2162            {
2163                resultSet.updateNull(name);
2164                
2165                return null;
2166            }
2167        };
2168        
2169        this.executeWriteToDriver(operation);
2170    }
2171
2172    /**
2173     * @see java.sql.ResultSet#updateObject(int, java.lang.Object)
2174     */
2175    public void updateObject(final int index, final Object   value) throws SQLException  
2176    {
2177        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
2178        {
2179            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
2180            {
2181                resultSet.updateObject(index, value);
2182                
2183                return null;
2184            }
2185        };
2186        
2187        this.executeWriteToDriver(operation);
2188    }
2189
2190    /**
2191     * @see java.sql.ResultSet#updateObject(int, java.lang.Object, int)
2192     */
2193    public void updateObject(final int index, final Object   value, final int sqlType) throws SQLException  
2194    {
2195        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
2196        {
2197            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
2198            {
2199                resultSet.updateObject(index, value, sqlType);
2200                
2201                return null;
2202            }
2203        };
2204        
2205        this.executeWriteToDriver(operation);
2206    }
2207
2208    /**
2209     * @see java.sql.ResultSet#updateObject(java.lang.String, java.lang.Object)
2210     */
2211    public void updateObject(final String   name, final Object   value) throws SQLException  
2212    {
2213        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
2214        {
2215            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
2216            {
2217                resultSet.updateObject(name, value);
2218                
2219                return null;
2220            }
2221        };
2222        
2223        this.executeWriteToDriver(operation);
2224    }
2225
2226    /**
2227     * @see java.sql.ResultSet#updateObject(java.lang.String, java.lang.Object, int)
2228     */
2229    public void updateObject(final String   name, final Object   value, final int sqlType) throws SQLException  
2230    {
2231        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
2232        {
2233            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
2234            {
2235                resultSet.updateObject(name, value, sqlType);
2236                
2237                return null;
2238            }
2239        };
2240        
2241        this.executeWriteToDriver(operation);
2242    }
2243
2244    /**
2245     * @see java.sql.ResultSet#updateRef(int, java.sql.Ref)
2246     */
2247    public void updateRef(final int index, final Ref   value) throws SQLException  
2248    {
2249        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
2250        {
2251            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
2252            {
2253                resultSet.updateRef(index, value);
2254                
2255                return null;
2256            }
2257        };
2258        
2259        this.executeWriteToDriver(operation);
2260    }
2261
2262    /**
2263     * @see java.sql.ResultSet#updateRef(java.lang.String, java.sql.Ref)
2264     */
2265    public void updateRef(final String   name, final Ref   value) throws SQLException  
2266    {
2267        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
2268        {
2269            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
2270            {
2271                resultSet.updateRef(name, value);
2272                
2273                return null;
2274            }
2275        };
2276        
2277        this.executeWriteToDriver(operation);
2278    }
2279
2280    /**
2281     * @see java.sql.ResultSet#updateRow()
2282     */
2283    public void updateRow() throws SQLException  
2284    {
2285        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
2286        {
2287            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
2288            {
2289                resultSet.updateRow();
2290                
2291                return null;
2292            }
2293        };
2294        
2295        this.executeTransactionalWriteToDatabase(operation);
2296    }
2297
2298    /**
2299     * @see java.sql.ResultSet#updateShort(int, short)
2300     */
2301    public void updateShort(final int index, final short value) throws SQLException  
2302    {
2303        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
2304        {
2305            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
2306            {
2307                resultSet.updateShort(index, value);
2308                
2309                return null;
2310            }
2311        };
2312        
2313        this.executeWriteToDriver(operation);
2314    }
2315
2316    /**
2317     * @see java.sql.ResultSet#updateShort(java.lang.String, short)
2318     */
2319    public void updateShort(final String   name, final short value) throws SQLException  
2320    {
2321        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
2322        {
2323            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
2324            {
2325                resultSet.updateShort(name, value);
2326                
2327                return null;
2328            }
2329        };
2330        
2331        this.executeWriteToDriver(operation);
2332    }
2333
2334    /**
2335     * @see java.sql.ResultSet#updateString(int, java.lang.String)
2336     */
2337    public void updateString(final int index, final String   value) throws SQLException  
2338    {
2339        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
2340        {
2341            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
2342            {
2343                resultSet.updateString(index, value);
2344                
2345                return null;
2346            }
2347        };
2348        
2349        this.executeWriteToDriver(operation);
2350    }
2351
2352    /**
2353     * @see java.sql.ResultSet#updateString(java.lang.String, java.lang.String)
2354     */
2355    public void updateString(final String   name, final String   value) throws SQLException  
2356    {
2357        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
2358        {
2359            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
2360            {
2361                resultSet.updateString(name, value);
2362                
2363                return null;
2364            }
2365        };
2366        
2367        this.executeWriteToDriver(operation);
2368    }
2369
2370    /**
2371     * @see java.sql.ResultSet#updateTime(int, java.sql.Time)
2372     */
2373    public void updateTime(final int index, final Time   value) throws SQLException  
2374    {
2375        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
2376        {
2377            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
2378            {
2379                resultSet.updateTime(index, value);
2380                
2381                return null;
2382            }
2383        };
2384        
2385        this.executeWriteToDriver(operation);
2386    }
2387
2388    /**
2389     * @see java.sql.ResultSet#updateTime(java.lang.String, java.sql.Time)
2390     */
2391    public void updateTime(final String   name, final Time   value) throws SQLException  
2392    {
2393        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
2394        {
2395            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
2396            {
2397                resultSet.updateTime(name, value);
2398                
2399                return null;
2400            }
2401        };
2402        
2403        this.executeWriteToDriver(operation);
2404    }
2405
2406    /**
2407     * @see java.sql.ResultSet#updateTimestamp(int, java.sql.Timestamp)
2408     */
2409    public void updateTimestamp(final int index, final Timestamp   value) throws SQLException  
2410    {
2411        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
2412        {
2413            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
2414            {
2415                resultSet.updateTimestamp(index, value);
2416                
2417                return null;
2418            }
2419        };
2420        
2421        this.executeWriteToDriver(operation);
2422    }
2423
2424    /**
2425     * @see java.sql.ResultSet#updateTimestamp(java.lang.String, java.sql.Timestamp)
2426     */
2427    public void updateTimestamp(final String   name, final Timestamp   value) throws SQLException  
2428    {
2429        Operation<java.sql.ResultSet  , Void  > operation = new Operation<java.sql.ResultSet  , Void  >()
2430        {
2431            public Void   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
2432            {
2433                resultSet.updateTimestamp(name, value);
2434                
2435                return null;
2436            }
2437        };
2438        
2439        this.executeWriteToDriver(operation);
2440    }
2441
2442    /**
2443     * @see java.sql.ResultSet#wasNull()
2444     */
2445    public boolean wasNull() throws SQLException  
2446    {
2447        Operation<java.sql.ResultSet  , Boolean  > operation = new Operation<java.sql.ResultSet  , Boolean  >()
2448        {
2449            public Boolean   execute(Database database, java.sql.ResultSet   resultSet) throws SQLException  
2450            {
2451                return resultSet.wasNull();
2452            }
2453        };
2454        
2455        return this.executeReadFromDriver(operation);
2456    }
2457    
2458    protected FileSupport getFileSupport() throws SQLException  
2459    {
2460        Connection connection = (Connection) this.getStatement().getConnection();
2461        
2462        return connection.getFileSupport();
2463    }
2464
2465    /**
2466     * @see net.sf.hajdbc.sql.SQLObject#close(java.lang.Object)
2467     */
2468    @Override  
2469    protected void close(java.sql.ResultSet   resultSet) throws SQLException  
2470    {
2471        resultSet.close();
2472    }
2473}
2474
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags