1 /***
2 * WrappedResultSet.java
3 *
4 * This file is part of the creme library.
5 * The creme library intends to ease the development effort of large
6 * applications by providing easy to use support classes.
7 *
8 * Copyright (C) 2002 Denis Bregeon
9 *
10 *
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
15 *
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 *
25 * contact information: dbregeon@sourceforge.net
26 */
27 package org.jcreme.sql;
28
29 import java.io.InputStream;
30 import java.io.Reader;
31 import java.math.BigDecimal;
32 import java.net.URL;
33 import java.sql.Array;
34 import java.sql.Blob;
35 import java.sql.Clob;
36 import java.sql.Date;
37 import java.sql.Ref;
38 import java.sql.ResultSet;
39 import java.sql.ResultSetMetaData;
40 import java.sql.SQLException;
41 import java.sql.SQLWarning;
42 import java.sql.Statement;
43 import java.sql.Time;
44 import java.sql.Timestamp;
45 import java.util.Calendar;
46 import java.util.Map;
47
48 /***
49 * This class enables to wrap an actual ResultSet to provide a few extra
50 * services: tracing of the queries, handling of some exceptions (rollback, loss
51 * of connection).
52 *
53 * @author $Author: dbregeon $
54 * @version $Revision: 1.1 $
55 */
56 public class WrappedResultSet implements ResultSet {
57 /***
58 * The String displayed when no query has been assigned to the ResultSet
59 * yet.
60 */
61 protected static final String UNKNOWN_QUERY = "Query Not Known Yet";
62
63 /***
64 * The underlying ResultSet.
65 */
66 private ResultSet actualResultSet = null;
67
68 /***
69 * The underlying Statement that generated the ResultSet.
70 */
71 private Statement underlyingStatement = null;
72
73 /***
74 * The query that produced the ResultSet.
75 */
76 private String actualQuery = UNKNOWN_QUERY;
77
78 /***
79 * The object that will handle the exceptions.
80 */
81 private SQLExceptionHandler exceptionHandler = null;
82
83 /***
84 * The action that will be used by the exception handler in case of
85 * rollback.
86 */
87 private CremeAction rollBackAction = null;
88
89 /***
90 * The action that will be used by the exception handler in case of loss of
91 * connection.
92 */
93 private CremeAction lossOfConnectionAction = null;
94
95 /***
96 * Enables to wrap a ResultSet.
97 *
98 * @param rs
99 * the ResultSet to wrap.
100 * @param stmt
101 * the Statement that produced this ResultSet.
102 * @param sql
103 * the query that produced this ResultSet.
104 * @throws SQLException
105 * if the statement is null.
106 */
107 public WrappedResultSet(ResultSet rs, Statement stmt, String sql)
108 throws SQLException {
109 if (rs == null) {
110 throw new SQLException("Null ResultSet.");
111 }
112 if (stmt == null) {
113 throw new SQLException("Null Statement.");
114 }
115 this.actualResultSet = rs;
116 this.underlyingStatement = stmt;
117 if (sql != null) {
118 this.actualQuery = sql;
119 }
120 WrappedConnection conn = WrappedConnection
121 .getInstance(this.actualResultSet.getStatement()
122 .getConnection());
123 this.rollBackAction = conn.getRollBackAction();
124 this.lossOfConnectionAction = conn.getLossOfConnectionAction();
125 this.exceptionHandler = conn.getExceptionHandler();
126 }
127
128 /***
129 * This method enables to generate an SQLException that contains the query
130 * of the ResultSet in its message.
131 *
132 * @param e
133 * the original exception.
134 * @return an exception which has the query as message.
135 */
136 protected SQLException generateException(SQLException e) {
137 String message = this.actualQuery + ": \n" + e.getMessage();
138 SQLException exc = null;
139 if ((this.exceptionHandler != null)
140 && (this.exceptionHandler.isDeadLock(e))) {
141 exc = generateDeadLockException(message, e);
142 } else if ((this.exceptionHandler != null)
143 && (this.exceptionHandler.isLossOfConnection(e))) {
144 exc = generateConnectionLostException(message, e);
145 } else {
146 exc = generateNewException(message, e);
147 }
148 exc.setNextException(e);
149 return exc;
150 }
151
152 /***
153 * This method generates a DeadLockException from an SQLException.
154 *
155 * @param message
156 * the message to append.
157 * @param e
158 * the original exception.
159 * @return a DeadLockException with the given message.
160 */
161 protected DeadLockException generateDeadLockException(String message,
162 SQLException e) {
163 return new DeadLockException(message, e.getSQLState(), e.getErrorCode());
164 }
165
166 /***
167 * This method generates a ConnectionLostException from an SQLException.
168 *
169 * @param message
170 * the message to append.
171 * @param e
172 * the original exception.
173 * @return a ConnectionLostException with the given message.
174 */
175 protected ConnectionLostException generateConnectionLostException(
176 String message, SQLException e) {
177 return new ConnectionLostException(message, e.getSQLState(), e
178 .getErrorCode());
179 }
180
181 /***
182 * This method generates a new SQLException from an SQLException.
183 *
184 * @param message
185 * the message to append.
186 * @param e
187 * the original exception.
188 * @return a new SQLException with the given message.
189 */
190 protected SQLException generateNewException(String message, SQLException e) {
191 return new SQLException(message, e.getSQLState(), e.getErrorCode());
192 }
193
194 /***
195 * This method enables to call upon an ExceptionHandler to manage the given
196 * exception. Both rollbacks and loss of connections are handled through
197 * this method.
198 *
199 * @param e
200 * exception to handle.
201 * @return the type of the exception as defined in the SQLExceptionHandler
202 * interface.
203 */
204 protected int manageException(SQLException e) {
205 int result = 0;
206 if (this.exceptionHandler != null) {
207 result = this.exceptionHandler.handleException(e,
208 this.rollBackAction, this.lossOfConnectionAction);
209 }
210 return result;
211 }
212
213 /***
214 * This method enables to call upon an ExceptionHandler to manage the given
215 * exception. Both rollbacks and loss of connections are handled through
216 * this method. This method also enables to redo the action that caused the
217 * original exception.
218 *
219 * @param e
220 * exception to handle.
221 * @param redo
222 * the action that caused the original exception.
223 * @return the type of the exception as defined in the SQLExceptionHandler
224 * interface.
225 */
226 protected int manageException(SQLException e, CremeAction redo) {
227 int result = 0;
228 if (this.exceptionHandler != null) {
229 result = this.exceptionHandler.handleException(e,
230 this.rollBackAction, this.lossOfConnectionAction, redo);
231 }
232 return result;
233 }
234
235 /***
236 * @see ResultSet#getInt(int)
237 */
238 public int getInt(int columnIndex) throws SQLException {
239 try {
240 return this.actualResultSet.getInt(columnIndex);
241 } catch (SQLException e) {
242 manageException(e);
243 throw generateException(e);
244 }
245 }
246
247 /***
248 * @see ResultSet#getRef(int)
249 */
250 public Ref getRef(int i) throws SQLException {
251 try {
252 return this.actualResultSet.getRef(i);
253 } catch (SQLException e) {
254 manageException(e);
255 throw generateException(e);
256 }
257 }
258
259 /***
260 * @see ResultSet#getDate(int)
261 */
262 public Date getDate(int columnIndex) throws SQLException {
263 try {
264 return this.actualResultSet.getDate(columnIndex);
265 } catch (SQLException e) {
266 manageException(e);
267 throw generateException(e);
268 }
269 }
270
271 /***
272 * @see ResultSet#getFetchSize()
273 */
274 public int getFetchSize() throws SQLException {
275 try {
276 return this.actualResultSet.getFetchSize();
277 } catch (SQLException e) {
278 manageException(e);
279 throw generateException(e);
280 }
281 }
282
283 /***
284 * @see ResultSet#getByte(int)
285 */
286 public byte getByte(int columnIndex) throws SQLException {
287 try {
288 return this.actualResultSet.getByte(columnIndex);
289 } catch (SQLException e) {
290 manageException(e);
291 throw generateException(e);
292 }
293 }
294
295 /***
296 * @see ResultSet#getBigDecimal(int)
297 */
298 public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
299 try {
300 return this.actualResultSet.getBigDecimal(columnIndex);
301 } catch (SQLException e) {
302 manageException(e);
303 throw generateException(e);
304 }
305 }
306
307 /***
308 * @see ResultSet#getShort(int)
309 */
310 public short getShort(int columnIndex) throws SQLException {
311 try {
312 return this.actualResultSet.getShort(columnIndex);
313 } catch (SQLException e) {
314 manageException(e);
315 throw generateException(e);
316 }
317 }
318
319 /***
320 * @see ResultSet#updateObject(int, java.lang.Object, int)
321 */
322 public void updateObject(int columnIndex, Object x, int scale)
323 throws SQLException {
324 try {
325 this.actualResultSet.updateObject(columnIndex, x, scale);
326 } catch (SQLException e) {
327 manageException(e);
328 throw generateException(e);
329 }
330 }
331
332 /***
333 * @see ResultSet#updateAsciiStream(java.lang.String, java.io.InputStream,
334 * int)
335 */
336 public void updateAsciiStream(String columnName, InputStream x, int length)
337 throws SQLException {
338 try {
339 this.actualResultSet.updateAsciiStream(columnName, x, length);
340 } catch (SQLException e) {
341 manageException(e);
342 throw generateException(e);
343 }
344 }
345
346 /***
347 * @see ResultSet#getDate(java.lang.String)
348 */
349 public Date getDate(String columnName) throws SQLException {
350 try {
351 return this.actualResultSet.getDate(columnName);
352 } catch (SQLException e) {
353 manageException(e);
354 throw generateException(e);
355 }
356 }
357
358 /***
359 * @see ResultSet#getObject(java.lang.String, java.util.Map)
360 */
361 public Object getObject(String colName, Map map) throws SQLException {
362 try {
363 return this.actualResultSet.getObject(colName, map);
364 } catch (SQLException e) {
365 manageException(e);
366 throw generateException(e);
367 }
368 }
369
370 /***
371 * @see ResultSet#updateBigDecimal(java.lang.String, java.math.BigDecimal)
372 */
373 public void updateBigDecimal(String columnName, BigDecimal x)
374 throws SQLException {
375 try {
376 this.actualResultSet.updateBigDecimal(columnName, x);
377 } catch (SQLException e) {
378 manageException(e);
379 throw generateException(e);
380 }
381 }
382
383 /***
384 * @see ResultSet#getTime(int)
385 */
386 public Time getTime(int columnIndex) throws SQLException {
387 try {
388 return this.actualResultSet.getTime(columnIndex);
389 } catch (SQLException e) {
390 manageException(e);
391 throw generateException(e);
392 }
393 }
394
395 /***
396 * @see ResultSet#getBigDecimal(int, int)
397 * @deprecated
398 */
399 public BigDecimal getBigDecimal(int columnIndex, int scale)
400 throws SQLException {
401 try {
402 return this.actualResultSet.getBigDecimal(columnIndex, scale);
403 } catch (SQLException e) {
404 manageException(e);
405 throw generateException(e);
406 }
407 }
408
409 /***
410 * @see ResultSet#getDouble(java.lang.String)
411 */
412 public double getDouble(String columnName) throws SQLException {
413 try {
414 return this.actualResultSet.getDouble(columnName);
415 } catch (SQLException e) {
416 manageException(e);
417 throw generateException(e);
418 }
419 }
420
421 /***
422 * @see ResultSet#getMetaData()
423 */
424 public ResultSetMetaData getMetaData() throws SQLException {
425 try {
426 return this.actualResultSet.getMetaData();
427 } catch (SQLException e) {
428 manageException(e);
429 throw generateException(e);
430 }
431 }
432
433 /***
434 * @see ResultSet#updateObject(java.lang.String, java.lang.Object)
435 */
436 public void updateObject(String columnName, Object x) throws SQLException {
437 try {
438 this.actualResultSet.updateObject(columnName, x);
439 } catch (SQLException e) {
440 manageException(e);
441 throw generateException(e);
442 }
443 }
444
445 /***
446 * @see ResultSet#first()
447 */
448 public boolean first() throws SQLException {
449 try {
450 return this.actualResultSet.first();
451 } catch (SQLException e) {
452 manageException(e);
453 throw generateException(e);
454 }
455 }
456
457 /***
458 * @see ResultSet#getTimestamp(int, java.util.Calendar)
459 */
460 public Timestamp getTimestamp(int columnIndex, Calendar cal)
461 throws SQLException {
462 try {
463 return this.actualResultSet.getTimestamp(columnIndex, cal);
464 } catch (SQLException e) {
465 manageException(e);
466 throw generateException(e);
467 }
468 }
469
470 /***
471 * @see ResultSet#getAsciiStream(java.lang.String)
472 */
473 public InputStream getAsciiStream(String columnName) throws SQLException {
474 try {
475 return this.actualResultSet.getAsciiStream(columnName);
476 } catch (SQLException e) {
477 manageException(e);
478 throw generateException(e);
479 }
480 }
481
482 /***
483 * @see ResultSet#getBinaryStream(java.lang.String)
484 */
485 public InputStream getBinaryStream(String columnName) throws SQLException {
486 try {
487 return this.actualResultSet.getBinaryStream(columnName);
488 } catch (SQLException e) {
489 manageException(e);
490 throw generateException(e);
491 }
492 }
493
494 /***
495 * @see ResultSet#getStatement()
496 */
497 public Statement getStatement() {
498 return this.underlyingStatement;
499 }
500
501 /***
502 * @see ResultSet#getFloat(int)
503 */
504 public float getFloat(int columnIndex) throws SQLException {
505 try {
506 return this.actualResultSet.getFloat(columnIndex);
507 } catch (SQLException e) {
508 manageException(e);
509 throw generateException(e);
510 }
511 }
512
513 /***
514 * @see ResultSet#getCharacterStream(java.lang.String)
515 */
516 public Reader getCharacterStream(String columnName) throws SQLException {
517 try {
518 return this.actualResultSet.getCharacterStream(columnName);
519 } catch (SQLException e) {
520 manageException(e);
521 throw generateException(e);
522 }
523 }
524
525 /***
526 * @see ResultSet#getInt(java.lang.String)
527 */
528 public int getInt(String columnName) throws SQLException {
529 try {
530 return this.actualResultSet.getInt(columnName);
531 } catch (SQLException e) {
532 manageException(e);
533 throw generateException(e);
534 }
535 }
536
537 /***
538 * @see ResultSet#updateBinaryStream(java.lang.String, java.io.InputStream,
539 * int)
540 */
541 public void updateBinaryStream(String columnName, InputStream x, int length)
542 throws SQLException {
543 try {
544 this.actualResultSet.updateBinaryStream(columnName, x, length);
545 } catch (SQLException e) {
546 manageException(e);
547 throw generateException(e);
548 }
549 }
550
551 /***
552 * @see ResultSet#updateFloat(int, float)
553 */
554 public void updateFloat(int columnIndex, float x) throws SQLException {
555 try {
556 this.actualResultSet.updateFloat(columnIndex, x);
557 } catch (SQLException e) {
558 manageException(e);
559 throw generateException(e);
560 }
561 }
562
563 /***
564 * @see ResultSet#clearWarnings()
565 */
566 public void clearWarnings() throws SQLException {
567 try {
568 this.actualResultSet.clearWarnings();
569 } catch (SQLException e) {
570 manageException(e);
571 throw generateException(e);
572 }
573 }
574
575 /***
576 * @see ResultSet#getCharacterStream(int)
577 */
578 public Reader getCharacterStream(int columnIndex) throws SQLException {
579 try {
580 return this.actualResultSet.getCharacterStream(columnIndex);
581 } catch (SQLException e) {
582 manageException(e);
583 throw generateException(e);
584 }
585 }
586
587 /***
588 * @see ResultSet#isFirst()
589 */
590 public boolean isFirst() throws SQLException {
591 try {
592 return this.actualResultSet.isFirst();
593 } catch (SQLException e) {
594 manageException(e);
595 throw generateException(e);
596 }
597 }
598
599 /***
600 * @see ResultSet#updateShort(int, short)
601 */
602 public void updateShort(int columnIndex, short x) throws SQLException {
603 try {
604 this.actualResultSet.updateShort(columnIndex, x);
605 } catch (SQLException e) {
606 manageException(e);
607 throw generateException(e);
608 }
609 }
610
611 /***
612 * @see ResultSet#updateBigDecimal(int, java.math.BigDecimal)
613 */
614 public void updateBigDecimal(int columnIndex, BigDecimal x)
615 throws SQLException {
616 try {
617 this.actualResultSet.updateBigDecimal(columnIndex, x);
618 } catch (SQLException e) {
619 manageException(e);
620 throw generateException(e);
621 }
622 }
623
624 /***
625 * @see ResultSet#cancelRowUpdates()
626 */
627 public void cancelRowUpdates() throws SQLException {
628 try {
629 this.actualResultSet.cancelRowUpdates();
630 } catch (SQLException e) {
631 manageException(e);
632 throw generateException(e);
633 }
634 }
635
636 /***
637 * @see ResultSet#updateBinaryStream(int, java.io.InputStream, int)
638 */
639 public void updateBinaryStream(int columnIndex, InputStream x, int length)
640 throws SQLException {
641 try {
642 this.actualResultSet.updateBinaryStream(columnIndex, x, length);
643 } catch (SQLException e) {
644 manageException(e);
645 throw generateException(e);
646 }
647 }
648
649 /***
650 * @see ResultSet#findColumn(java.lang.String)
651 */
652 public int findColumn(String columnName) throws SQLException {
653 try {
654 return this.actualResultSet.findColumn(columnName);
655 } catch (SQLException e) {
656 manageException(e);
657 throw generateException(e);
658 }
659 }
660
661 /***
662 * @see ResultSet#getTime(java.lang.String)
663 */
664 public Time getTime(String columnName) throws SQLException {
665 try {
666 return this.actualResultSet.getTime(columnName);
667 } catch (SQLException e) {
668 manageException(e);
669 throw generateException(e);
670 }
671 }
672
673 /***
674 * @see ResultSet#getUnicodeStream(int)
675 * @deprecated
676 */
677 public InputStream getUnicodeStream(int columnIndex) throws SQLException {
678 try {
679 return this.actualResultSet.getUnicodeStream(columnIndex);
680 } catch (SQLException e) {
681 manageException(e);
682 throw generateException(e);
683 }
684 }
685
686 /***
687 * @see ResultSet#getString(java.lang.String)
688 */
689 public String getString(String columnName) throws SQLException {
690 try {
691 return this.actualResultSet.getString(columnName);
692 } catch (SQLException e) {
693 manageException(e);
694 throw generateException(e);
695 }
696 }
697
698 /***
699 * @see ResultSet#getBytes(java.lang.String)
700 */
701 public byte[] getBytes(String columnName) throws SQLException {
702 try {
703 return this.actualResultSet.getBytes(columnName);
704 } catch (SQLException e) {
705 manageException(e);
706 throw generateException(e);
707 }
708 }
709
710 /***
711 * @see ResultSet#beforeFirst()
712 */
713 public void beforeFirst() throws SQLException {
714 try {
715 this.actualResultSet.beforeFirst();
716 } catch (SQLException e) {
717 manageException(e);
718 throw generateException(e);
719 }
720 }
721
722 /***
723 * @see ResultSet#updateString(int, java.lang.String)
724 */
725 public void updateString(int columnIndex, String x) throws SQLException {
726 try {
727 this.actualResultSet.updateString(columnIndex, x);
728 } catch (SQLException e) {
729 manageException(e);
730 throw generateException(e);
731 }
732 }
733
734 /***
735 * @see ResultSet#updateByte(java.lang.String, byte)
736 */
737 public void updateByte(String columnName, byte x) throws SQLException {
738 try {
739 this.actualResultSet.updateByte(columnName, x);
740 } catch (SQLException e) {
741 manageException(e);
742 throw generateException(e);
743 }
744 }
745
746 /***
747 * @see ResultSet#getCursorName()
748 */
749 public String getCursorName() throws SQLException {
750 try {
751 return this.actualResultSet.getCursorName();
752 } catch (SQLException e) {
753 manageException(e);
754 throw generateException(e);
755 }
756 }
757
758 /***
759 * @see ResultSet#rowDeleted()
760 */
761 public boolean rowDeleted() throws SQLException {
762 try {
763 return this.actualResultSet.rowDeleted();
764 } catch (SQLException e) {
765 manageException(e);
766 throw generateException(e);
767 }
768 }
769
770 /***
771 * @see ResultSet#getFetchDirection()
772 */
773 public int getFetchDirection() throws SQLException {
774 try {
775 return this.actualResultSet.getFetchDirection();
776 } catch (SQLException e) {
777 manageException(e);
778 throw generateException(e);
779 }
780 }
781
782 /***
783 * @see ResultSet#updateInt(int, int)
784 */
785 public void updateInt(int columnIndex, int x) throws SQLException {
786 try {
787 this.actualResultSet.updateInt(columnIndex, x);
788 } catch (SQLException e) {
789 manageException(e);
790 throw generateException(e);
791 }
792 }
793
794 /***
795 * @see ResultSet#getLong(int)
796 */
797 public long getLong(int columnIndex) throws SQLException {
798 try {
799 return this.actualResultSet.getLong(columnIndex);
800 } catch (SQLException e) {
801 manageException(e);
802 throw generateException(e);
803 }
804 }
805
806 /***
807 * @see ResultSet#updateBoolean(java.lang.String, boolean)
808 */
809 public void updateBoolean(String columnName, boolean x) throws SQLException {
810 try {
811 this.actualResultSet.updateBoolean(columnName, x);
812 } catch (SQLException e) {
813 manageException(e);
814 throw generateException(e);
815 }
816 }
817
818 /***
819 * @see ResultSet#updateTime(java.lang.String, java.sql.Time)
820 */
821 public void updateTime(String columnName, Time x) throws SQLException {
822 try {
823 this.actualResultSet.updateTime(columnName, x);
824 } catch (SQLException e) {
825 manageException(e);
826 throw generateException(e);
827 }
828 }
829
830 /***
831 * @see ResultSet#getBoolean(int)
832 */
833 public boolean getBoolean(int columnIndex) throws SQLException {
834 try {
835 return this.actualResultSet.getBoolean(columnIndex);
836 } catch (SQLException e) {
837 manageException(e);
838 throw generateException(e);
839 }
840 }
841
842 /***
843 * @see ResultSet#afterLast()
844 */
845 public void afterLast() throws SQLException {
846 try {
847 this.actualResultSet.afterLast();
848 } catch (SQLException e) {
849 manageException(e);
850 throw generateException(e);
851 }
852 }
853
854 /***
855 * @see ResultSet#getDate(int, java.util.Calendar)
856 */
857 public Date getDate(int columnIndex, Calendar cal) throws SQLException {
858 try {
859 return this.actualResultSet.getDate(columnIndex, cal);
860 } catch (SQLException e) {
861 manageException(e);
862 throw generateException(e);
863 }
864 }
865
866 /***
867 * @see ResultSet#last()
868 */
869 public boolean last() throws SQLException {
870 try {
871 return this.actualResultSet.last();
872 } catch (SQLException e) {
873 manageException(e);
874 throw generateException(e);
875 }
876 }
877
878 /***
879 * @see ResultSet#getType()
880 */
881 public int getType() throws SQLException {
882 try {
883 return this.actualResultSet.getType();
884 } catch (SQLException e) {
885 manageException(e);
886 throw generateException(e);
887 }
888 }
889
890 /***
891 * @see ResultSet#getArray(java.lang.String)
892 */
893 public Array getArray(String colName) throws SQLException {
894 try {
895 return this.actualResultSet.getArray(colName);
896 } catch (SQLException e) {
897 manageException(e);
898 throw generateException(e);
899 }
900 }
901
902 /***
903 * @see ResultSet#close()
904 */
905 public void close() throws SQLException {
906 try {
907 this.actualResultSet.close();
908 } catch (SQLException e) {
909 manageException(e);
910 throw generateException(e);
911 }
912 }
913
914 /***
915 * @see ResultSet#getRow()
916 */
917 public int getRow() throws SQLException {
918 try {
919 return this.actualResultSet.getRow();
920 } catch (SQLException e) {
921 manageException(e);
922 throw generateException(e);
923 }
924 }
925
926 /***
927 * @see ResultSet#deleteRow()
928 */
929 public void deleteRow() throws SQLException {
930 try {
931 this.actualResultSet.deleteRow();
932 } catch (SQLException e) {
933 manageException(e);
934 throw generateException(e);
935 }
936 }
937
938 /***
939 * @see ResultSet#updateLong(int, long)
940 */
941 public void updateLong(int columnIndex, long x) throws SQLException {
942 try {
943 this.actualResultSet.updateLong(columnIndex, x);
944 } catch (SQLException e) {
945 manageException(e);
946 throw generateException(e);
947 }
948 }
949
950 /***
951 * @see ResultSet#getLong(java.lang.String)
952 */
953 public long getLong(String columnName) throws SQLException {
954 try {
955 return this.actualResultSet.getLong(columnName);
956 } catch (SQLException e) {
957 manageException(e);
958 throw generateException(e);
959 }
960 }
961
962 /***
963 * @see ResultSet#updateInt(java.lang.String, int)
964 */
965 public void updateInt(String columnName, int x) throws SQLException {
966 try {
967 this.actualResultSet.updateInt(columnName, x);
968 } catch (SQLException e) {
969 manageException(e);
970 throw generateException(e);
971 }
972 }
973
974 /***
975 * @see ResultSet#updateBytes(int, byte[])
976 */
977 public void updateBytes(int columnIndex, byte x[]) throws SQLException {
978 try {
979 this.actualResultSet.updateBytes(columnIndex, x);
980 } catch (SQLException e) {
981 manageException(e);
982 throw generateException(e);
983 }
984 }
985
986 /***
987 * @see ResultSet#getTimestamp(java.lang.String)
988 */
989 public Timestamp getTimestamp(String columnName) throws SQLException {
990 try {
991 return this.actualResultSet.getTimestamp(columnName);
992 } catch (SQLException e) {
993 manageException(e);
994 throw generateException(e);
995 }
996 }
997
998 /***
999 * @see ResultSet#getRef(java.lang.String)
1000 */
1001 public Ref getRef(String colName) throws SQLException {
1002 try {
1003 return this.actualResultSet.getRef(colName);
1004 } catch (SQLException e) {
1005 manageException(e);
1006 throw generateException(e);
1007 }
1008 }
1009
1010 /***
1011 * @see ResultSet#getTimestamp(int)
1012 */
1013 public Timestamp getTimestamp(int columnIndex) throws SQLException {
1014 try {
1015 return this.actualResultSet.getTimestamp(columnIndex);
1016 } catch (SQLException e) {
1017 manageException(e);
1018 throw generateException(e);
1019 }
1020 }
1021
1022 /***
1023 * @see ResultSet#getBigDecimal(java.lang.String, int)
1024 * @deprecated
1025 */
1026 public BigDecimal getBigDecimal(String columnName, int scale)
1027 throws SQLException {
1028 try {
1029 return this.actualResultSet.getBigDecimal(columnName, scale);
1030 } catch (SQLException e) {
1031 manageException(e);
1032 throw generateException(e);
1033 }
1034 }
1035
1036 /***
1037 * @see ResultSet#updateDouble(java.lang.String, double)
1038 */
1039 public void updateDouble(String columnName, double x) throws SQLException {
1040 try {
1041 this.actualResultSet.updateDouble(columnName, x);
1042 } catch (SQLException e) {
1043 manageException(e);
1044 throw generateException(e);
1045 }
1046 }
1047
1048 /***
1049 * @see ResultSet#rowUpdated()
1050 */
1051 public boolean rowUpdated() throws SQLException {
1052 try {
1053 return this.actualResultSet.rowUpdated();
1054 } catch (SQLException e) {
1055 manageException(e);
1056 throw generateException(e);
1057 }
1058 }
1059
1060 /***
1061 * @see ResultSet#getBlob(java.lang.String)
1062 */
1063 public Blob getBlob(String colName) throws SQLException {
1064 try {
1065 return this.actualResultSet.getBlob(colName);
1066 } catch (SQLException e) {
1067 manageException(e);
1068 throw generateException(e);
1069 }
1070 }
1071
1072 /***
1073 * @see ResultSet#getObject(int, java.util.Map)
1074 */
1075 public Object getObject(int i, Map map) throws SQLException {
1076 try {
1077 return this.actualResultSet.getObject(i, map);
1078 } catch (SQLException e) {
1079 manageException(e);
1080 throw generateException(e);
1081 }
1082 }
1083
1084 /***
1085 * @see ResultSet#getObject(int)
1086 */
1087 public Object getObject(int columnIndex) throws SQLException {
1088 try {
1089 return this.actualResultSet.getObject(columnIndex);
1090 } catch (SQLException e) {
1091 manageException(e);
1092 throw generateException(e);
1093 }
1094 }
1095
1096 /***
1097 * @see ResultSet#getBoolean(java.lang.String)
1098 */
1099 public boolean getBoolean(String columnName) throws SQLException {
1100 try {
1101 return this.actualResultSet.getBoolean(columnName);
1102 } catch (SQLException e) {
1103 manageException(e);
1104 throw generateException(e);
1105 }
1106 }
1107
1108 /***
1109 * @see ResultSet#updateObject(java.lang.String, java.lang.Object,int)
1110 */
1111 public void updateObject(String columnName, Object x, int scale)
1112 throws SQLException {
1113 try {
1114 this.actualResultSet.updateObject(columnName, x, scale);
1115 } catch (SQLException e) {
1116 manageException(e);
1117 throw generateException(e);
1118 }
1119 }
1120
1121 /***
1122 * @see ResultSet#getWarnings()
1123 */
1124 public SQLWarning getWarnings() throws SQLException {
1125 try {
1126 return this.actualResultSet.getWarnings();
1127 } catch (SQLException e) {
1128 manageException(e);
1129 throw generateException(e);
1130 }
1131 }
1132
1133 /***
1134 * @see ResultSet#relative(int)
1135 */
1136 public boolean relative(int rows) throws SQLException {
1137 try {
1138 return this.actualResultSet.relative(rows);
1139 } catch (SQLException e) {
1140 manageException(e);
1141 throw generateException(e);
1142 }
1143 }
1144
1145 /***
1146 * @see ResultSet#getBytes(int)
1147 */
1148 public byte[] getBytes(int columnIndex) throws SQLException {
1149 try {
1150 return this.actualResultSet.getBytes(columnIndex);
1151 } catch (SQLException e) {
1152 manageException(e);
1153 throw generateException(e);
1154 }
1155 }
1156
1157 /***
1158 * @see ResultSet#getBigDecimal(java.lang.String)
1159 */
1160 public BigDecimal getBigDecimal(String columnName) throws SQLException {
1161 try {
1162 return this.actualResultSet.getBigDecimal(columnName);
1163 } catch (SQLException e) {
1164 manageException(e);
1165 throw generateException(e);
1166 }
1167 }
1168
1169 /***
1170 * @see ResultSet#updateObject(int, java.lang.Object)
1171 */
1172 public void updateObject(int columnIndex, Object x) throws SQLException {
1173 try {
1174 this.actualResultSet.updateObject(columnIndex, x);
1175 } catch (SQLException e) {
1176 manageException(e);
1177 throw generateException(e);
1178 }
1179 }
1180
1181 /***
1182 * @see ResultSet#updateNull(java.lang.String)
1183 */
1184 public void updateNull(String columnName) throws SQLException {
1185 try {
1186 this.actualResultSet.updateNull(columnName);
1187 } catch (SQLException e) {
1188 manageException(e);
1189 throw generateException(e);
1190 }
1191 }
1192
1193 /***
1194 * @see ResultSet#updateTimestamp(int, java.sql.Timestamp)
1195 */
1196 public void updateTimestamp(int columnIndex, Timestamp x)
1197 throws SQLException {
1198 try {
1199 this.actualResultSet.updateTimestamp(columnIndex, x);
1200 } catch (SQLException e) {
1201 manageException(e);
1202 throw generateException(e);
1203 }
1204 }
1205
1206 /***
1207 * @see ResultSet#setFetchSize(int)
1208 */
1209 public void setFetchSize(int rows) throws SQLException {
1210 try {
1211 this.actualResultSet.setFetchSize(rows);
1212 } catch (SQLException e) {
1213 manageException(e);
1214 throw generateException(e);
1215 }
1216 }
1217
1218 /***
1219 * @see ResultSet#updateDate(int, java.sql.Date)
1220 */
1221 public void updateDate(int columnIndex, Date x) throws SQLException {
1222 try {
1223 this.actualResultSet.updateDate(columnIndex, x);
1224 } catch (SQLException e) {
1225 manageException(e);
1226 throw generateException(e);
1227 }
1228 }
1229
1230 /***
1231 * @see ResultSet#getClob(int)
1232 */
1233 public Clob getClob(int i) throws SQLException {
1234 try {
1235 return this.actualResultSet.getClob(i);
1236 } catch (SQLException e) {
1237 manageException(e);
1238 throw generateException(e);
1239 }
1240 }
1241
1242 /***
1243 * @see ResultSet#updateNull(int)
1244 */
1245 public void updateNull(int columnIndex) throws SQLException {
1246 try {
1247 this.actualResultSet.updateNull(columnIndex);
1248 } catch (SQLException e) {
1249 manageException(e);
1250 throw generateException(e);
1251 }
1252 }
1253
1254 /***
1255 * @see ResultSet#getClob(java.lang.String)
1256 */
1257 public Clob getClob(String colName) throws SQLException {
1258 try {
1259 return this.actualResultSet.getClob(colName);
1260 } catch (SQLException e) {
1261 manageException(e);
1262 throw generateException(e);
1263 }
1264 }
1265
1266 /***
1267 * @see ResultSet#updateAsciiStream(int, java.io.InputStream, int)
1268 */
1269 public void updateAsciiStream(int columnIndex, InputStream x, int length)
1270 throws SQLException {
1271 try {
1272 this.actualResultSet.updateAsciiStream(columnIndex, x, length);
1273 } catch (SQLException e) {
1274 manageException(e);
1275 throw generateException(e);
1276 }
1277 }
1278
1279 /***
1280 * @see ResultSet#getObject(java.lang.String)
1281 */
1282 public Object getObject(String columnName) throws SQLException {
1283 try {
1284 return this.actualResultSet.getObject(columnName);
1285 } catch (SQLException e) {
1286 manageException(e);
1287 throw generateException(e);
1288 }
1289 }
1290
1291 /***
1292 * @see ResultSet#isLast()
1293 */
1294 public boolean isLast() throws SQLException {
1295 try {
1296 return this.actualResultSet.isLast();
1297 } catch (SQLException e) {
1298 manageException(e);
1299 throw generateException(e);
1300 }
1301 }
1302
1303 /***
1304 * @see ResultSet#getFloat(java.lang.String)
1305 */
1306 public float getFloat(String columnName) throws SQLException {
1307 try {
1308 return this.actualResultSet.getFloat(columnName);
1309 } catch (SQLException e) {
1310 manageException(e);
1311 throw generateException(e);
1312 }
1313 }
1314
1315 /***
1316 * @see ResultSet#isBeforeFirst()
1317 */
1318 public boolean isBeforeFirst() throws SQLException {
1319 try {
1320 return this.actualResultSet.isBeforeFirst();
1321 } catch (SQLException e) {
1322 manageException(e);
1323 throw generateException(e);
1324 }
1325 }
1326
1327 /***
1328 * @see ResultSet#updateLong(java.lang.String, long)
1329 */
1330 public void updateLong(String columnName, long x) throws SQLException {
1331 try {
1332 this.actualResultSet.updateLong(columnName, x);
1333 } catch (SQLException e) {
1334 manageException(e);
1335 throw generateException(e);
1336 }
1337 }
1338
1339 /***
1340 * @see ResultSet#updateBoolean(int, boolean)
1341 */
1342 public void updateBoolean(int columnIndex, boolean x) throws SQLException {
1343 try {
1344 this.actualResultSet.updateBoolean(columnIndex, x);
1345 } catch (SQLException e) {
1346 manageException(e);
1347 throw generateException(e);
1348 }
1349 }
1350
1351 /***
1352 * @see ResultSet#getDate(java.lang.String, java.util.Calendar)
1353 */
1354 public Date getDate(String columnName, Calendar cal) throws SQLException {
1355 try {
1356 return this.actualResultSet.getDate(columnName, cal);
1357 } catch (SQLException e) {
1358 manageException(e);
1359 throw generateException(e);
1360 }
1361 }
1362
1363 /***
1364 * @see ResultSet#getConcurrency()
1365 */
1366 public int getConcurrency() throws SQLException {
1367 try {
1368 return this.actualResultSet.getConcurrency();
1369 } catch (SQLException e) {
1370 manageException(e);
1371 throw generateException(e);
1372 }
1373 }
1374
1375 /***
1376 * @see ResultSet#getTime(int, java.util.Calendar)
1377 */
1378 public Time getTime(int columnIndex, Calendar cal) throws SQLException {
1379 try {
1380 return this.actualResultSet.getTime(columnIndex, cal);
1381 } catch (SQLException e) {
1382 manageException(e);
1383 throw generateException(e);
1384 }
1385 }
1386
1387 /***
1388 * @see ResultSet#updateBytes(java.lang.String, byte[])
1389 */
1390 public void updateBytes(String columnName, byte x[]) throws SQLException {
1391 try {
1392 this.actualResultSet.updateBytes(columnName, x);
1393 } catch (SQLException e) {
1394 manageException(e);
1395 throw generateException(e);
1396 }
1397 }
1398
1399 /***
1400 * @see ResultSet#getBlob(int)
1401 */
1402 public Blob getBlob(int i) throws SQLException {
1403 try {
1404 return this.actualResultSet.getBlob(i);
1405 } catch (SQLException e) {
1406 manageException(e);
1407 throw generateException(e);
1408 }
1409 }
1410
1411 /***
1412 * @see ResultSet#getDouble(int)
1413 */
1414 public double getDouble(int columnIndex) throws SQLException {
1415 try {
1416 return this.actualResultSet.getDouble(columnIndex);
1417 } catch (SQLException e) {
1418 manageException(e);
1419 throw generateException(e);
1420 }
1421 }
1422
1423 /***
1424 * @see ResultSet#updateShort(java.lang.String, short)
1425 */
1426 public void updateShort(String columnName, short x) throws SQLException {
1427 try {
1428 this.actualResultSet.updateShort(columnName, x);
1429 } catch (SQLException e) {
1430 manageException(e);
1431 throw generateException(e);
1432 }
1433 }
1434
1435 /***
1436 * @see ResultSet#getAsciiStream(int)
1437 */
1438 public InputStream getAsciiStream(int columnIndex) throws SQLException {
1439 try {
1440 return this.actualResultSet.getAsciiStream(columnIndex);
1441 } catch (SQLException e) {
1442 manageException(e);
1443 throw generateException(e);
1444 }
1445 }
1446
1447 /***
1448 * @see ResultSet#setFetchDirection(int)
1449 */
1450 public void setFetchDirection(int direction) throws SQLException {
1451 try {
1452 this.actualResultSet.setFetchDirection(direction);
1453 } catch (SQLException e) {
1454 manageException(e);
1455 throw generateException(e);
1456 }
1457 }
1458
1459 /***
1460 * @see ResultSet#moveToCurrentRow()
1461 */
1462 public void moveToCurrentRow() throws SQLException {
1463 try {
1464 this.actualResultSet.moveToCurrentRow();
1465 } catch (SQLException e) {
1466 manageException(e);
1467 throw generateException(e);
1468 }
1469 }
1470
1471 /***
1472 * @see ResultSet#updateTime(int, java.sql.Time)
1473 */
1474 public void updateTime(int columnIndex, Time x) throws SQLException {
1475 try {
1476 this.actualResultSet.updateTime(columnIndex, x);
1477 } catch (SQLException e) {
1478 manageException(e);
1479 throw generateException(e);
1480 }
1481 }
1482
1483 /***
1484 * @see ResultSet#updateCharacterStream(int, java.io.Reader, int)
1485 */
1486 public void updateCharacterStream(int columnIndex, Reader x, int length)
1487 throws SQLException {
1488 try {
1489 this.actualResultSet.updateCharacterStream(columnIndex, x, length);
1490 } catch (SQLException e) {
1491 manageException(e);
1492 throw generateException(e);
1493 }
1494 }
1495
1496 /***
1497 * @see ResultSet#getUnicodeStream(java.lang.String)
1498 * @deprecated use <code>getCharacterStream</code> instead
1499 */
1500 public InputStream getUnicodeStream(String columnName) throws SQLException {
1501 try {
1502 return this.actualResultSet.getUnicodeStream(columnName);
1503 } catch (SQLException e) {
1504 manageException(e);
1505 throw generateException(e);
1506 }
1507 }
1508
1509 /***
1510 * @see ResultSet#updateRow()
1511 */
1512 public void updateRow() throws SQLException {
1513 try {
1514 this.actualResultSet.updateRow();
1515 } catch (SQLException e) {
1516 manageException(e);
1517 throw generateException(e);
1518 }
1519 }
1520
1521 /***
1522 * @see ResultSet#updateCharacterStream(java.lang.String, java.io.Reader,
1523 * int)
1524 */
1525 public void updateCharacterStream(String columnName, Reader reader,
1526 int length) throws SQLException {
1527 try {
1528 this.actualResultSet.updateCharacterStream(columnName, reader,
1529 length);
1530 } catch (SQLException e) {
1531 manageException(e);
1532 throw generateException(e);
1533 }
1534 }
1535
1536 /***
1537 * @see ResultSet#getByte(java.lang.String)
1538 */
1539 public byte getByte(String columnName) throws SQLException {
1540 try {
1541 return this.actualResultSet.getByte(columnName);
1542 } catch (SQLException e) {
1543 manageException(e);
1544 throw generateException(e);
1545 }
1546 }
1547
1548 /***
1549 * @see ResultSet#updateString(java.lang.String, java.lang.String)
1550 */
1551 public void updateString(String columnName, String x) throws SQLException {
1552 try {
1553 this.actualResultSet.updateString(columnName, x);
1554 } catch (SQLException e) {
1555 manageException(e);
1556 throw generateException(e);
1557 }
1558 }
1559
1560 /***
1561 * @see ResultSet#rowInserted()
1562 */
1563 public boolean rowInserted() throws SQLException {
1564 try {
1565 return this.actualResultSet.rowInserted();
1566 } catch (SQLException e) {
1567 manageException(e);
1568 throw generateException(e);
1569 }
1570 }
1571
1572 /***
1573 * @see ResultSet#updateFloat(java.lang.String, float)
1574 */
1575 public void updateFloat(String columnName, float x) throws SQLException {
1576 try {
1577 this.actualResultSet.updateFloat(columnName, x);
1578 } catch (SQLException e) {
1579 manageException(e);
1580 throw generateException(e);
1581 }
1582 }
1583
1584 /***
1585 * @see ResultSet#insertRow()
1586 */
1587 public void insertRow() throws SQLException {
1588 try {
1589 this.actualResultSet.insertRow();
1590 } catch (SQLException e) {
1591 manageException(e);
1592 throw generateException(e);
1593 }
1594 }
1595
1596 /***
1597 * @see ResultSet#getBinaryStream(int)
1598 */
1599 public InputStream getBinaryStream(int columnIndex) throws SQLException {
1600 try {
1601 return this.actualResultSet.getBinaryStream(columnIndex);
1602 } catch (SQLException e) {
1603 manageException(e);
1604 throw generateException(e);
1605 }
1606 }
1607
1608 /***
1609 * @see ResultSet#updateDouble(int, double)
1610 */
1611 public void updateDouble(int columnIndex, double x) throws SQLException {
1612 try {
1613 this.actualResultSet.updateDouble(columnIndex, x);
1614 } catch (SQLException e) {
1615 manageException(e);
1616 throw generateException(e);
1617 }
1618 }
1619
1620 /***
1621 * @see ResultSet#moveToInsertRow()
1622 */
1623 public void moveToInsertRow() throws SQLException {
1624 try {
1625 this.actualResultSet.moveToInsertRow();
1626 } catch (SQLException e) {
1627 manageException(e);
1628 throw generateException(e);
1629 }
1630 }
1631
1632 /***
1633 * @see ResultSet#next()
1634 */
1635 public boolean next() throws SQLException {
1636 try {
1637 return this.actualResultSet.next();
1638 } catch (SQLException e) {
1639 CremeAction redo = null;
1640 try {
1641 redo = new CremeAction(getClass().getMethod("next",
1642 new Class[0]));
1643 redo.setSubject(this);
1644 } catch (NoSuchMethodException ex) {
1645 ex.printStackTrace();
1646 } catch (IllegalArgumentException ex) {
1647 ex.printStackTrace();
1648 }
1649 manageException(e, redo);
1650 if (redo != null && redo.isSuccessfull()) {
1651 return ((Boolean) redo.getResult()).booleanValue();
1652 }
1653 throw generateException(e);
1654 }
1655 }
1656
1657 /***
1658 * @see ResultSet#getTimestamp(java.lang.String, java.util.Calendar)
1659 */
1660 public Timestamp getTimestamp(String columnName, Calendar cal)
1661 throws SQLException {
1662 try {
1663 return this.actualResultSet.getTimestamp(columnName, cal);
1664 } catch (SQLException e) {
1665 manageException(e);
1666 throw generateException(e);
1667 }
1668 }
1669
1670 /***
1671 * @see ResultSet#getShort(java.lang.String)
1672 */
1673 public short getShort(String columnName) throws SQLException {
1674 try {
1675 return this.actualResultSet.getShort(columnName);
1676 } catch (SQLException e) {
1677 manageException(e);
1678 throw generateException(e);
1679 }
1680 }
1681
1682 /***
1683 * @see ResultSet#getTime(java.lang.String, java.util.Calendar)
1684 */
1685 public Time getTime(String columnName, Calendar cal) throws SQLException {
1686 try {
1687 return this.actualResultSet.getTime(columnName, cal);
1688 } catch (SQLException e) {
1689 manageException(e);
1690 throw generateException(e);
1691 }
1692 }
1693
1694 /***
1695 * @see ResultSet#absolute(int)
1696 */
1697 public boolean absolute(int row) throws SQLException {
1698 try {
1699 return this.actualResultSet.absolute(row);
1700 } catch (SQLException e) {
1701 manageException(e);
1702 throw generateException(e);
1703 }
1704 }
1705
1706 /***
1707 * @see ResultSet#updateDate(java.lang.String, java.sql.Date)
1708 */
1709 public void updateDate(String columnName, Date x) throws SQLException {
1710 try {
1711 this.actualResultSet.updateDate(columnName, x);
1712 } catch (SQLException e) {
1713 manageException(e);
1714 throw generateException(e);
1715 }
1716 }
1717
1718 /***
1719 * @see ResultSet#wasNull()
1720 */
1721 public boolean wasNull() throws SQLException {
1722 try {
1723 return this.actualResultSet.wasNull();
1724 } catch (SQLException e) {
1725 manageException(e);
1726 throw generateException(e);
1727 }
1728 }
1729
1730 /***
1731 * @see ResultSet#previous()
1732 */
1733 public boolean previous() throws SQLException {
1734 try {
1735 return this.actualResultSet.previous();
1736 } catch (SQLException e) {
1737 manageException(e);
1738 throw generateException(e);
1739 }
1740 }
1741
1742 /***
1743 * @see ResultSet#getArray(int)
1744 */
1745 public Array getArray(int i) throws SQLException {
1746 try {
1747 return this.actualResultSet.getArray(i);
1748 } catch (SQLException e) {
1749 manageException(e);
1750 throw generateException(e);
1751 }
1752 }
1753
1754 /***
1755 * @see ResultSet#refreshRow()
1756 */
1757 public void refreshRow() throws SQLException {
1758 try {
1759 this.actualResultSet.refreshRow();
1760 } catch (SQLException e) {
1761 manageException(e);
1762 throw generateException(e);
1763 }
1764 }
1765
1766 /***
1767 * @see ResultSet#updateTimestamp(java.lang.String, java.sql.Timestamp)
1768 */
1769 public void updateTimestamp(String columnName, Timestamp x)
1770 throws SQLException {
1771 try {
1772 this.actualResultSet.updateTimestamp(columnName, x);
1773 } catch (SQLException e) {
1774 manageException(e);
1775 throw generateException(e);
1776 }
1777 }
1778
1779 /***
1780 * @see ResultSet#updateByte(int, byte)
1781 */
1782 public void updateByte(int columnIndex, byte x) throws SQLException {
1783 try {
1784 this.actualResultSet.updateByte(columnIndex, x);
1785 } catch (SQLException e) {
1786 manageException(e);
1787 throw generateException(e);
1788 }
1789 }
1790
1791 /***
1792 * @see ResultSet#isAfterLast()
1793 */
1794 public boolean isAfterLast() throws SQLException {
1795 try {
1796 return this.actualResultSet.isAfterLast();
1797 } catch (SQLException e) {
1798 manageException(e);
1799 throw generateException(e);
1800 }
1801 }
1802
1803 /***
1804 * @see ResultSet#getString(int)
1805 */
1806 public String getString(int columnIndex) throws SQLException {
1807 try {
1808 return this.actualResultSet.getString(columnIndex);
1809 } catch (SQLException e) {
1810 manageException(e);
1811 throw generateException(e);
1812 }
1813 }
1814
1815 /***
1816 * @see ResultSet#getURL(int)
1817 */
1818 public URL getURL(int columnIndex) throws SQLException {
1819 try {
1820 return this.actualResultSet.getURL(columnIndex);
1821 } catch (SQLException e) {
1822 manageException(e);
1823 throw generateException(e);
1824 }
1825 }
1826
1827 /***
1828 * @see ResultSet#getURL(java.lang.String)
1829 */
1830 public URL getURL(String columnName) throws SQLException {
1831 try {
1832 return this.actualResultSet.getURL(columnName);
1833 } catch (SQLException e) {
1834 manageException(e);
1835 throw generateException(e);
1836 }
1837 }
1838
1839 /***
1840 * @see ResultSet#updateRef(int, java.sql.Ref)
1841 */
1842 public void updateRef(int columnIndex, Ref x) throws SQLException {
1843 try {
1844 this.actualResultSet.updateRef(columnIndex, x);
1845 } catch (SQLException e) {
1846 manageException(e);
1847 throw generateException(e);
1848 }
1849 }
1850
1851 /***
1852 * @see ResultSet#updateRef(java.lang.String, java.sql.Ref)
1853 */
1854 public void updateRef(String columnName, Ref x) throws SQLException {
1855 try {
1856 this.actualResultSet.updateRef(columnName, x);
1857 } catch (SQLException e) {
1858 manageException(e);
1859 throw generateException(e);
1860 }
1861 }
1862
1863 /***
1864 * @see ResultSet#updateBlob(int, java.sql.Blob)
1865 */
1866 public void updateBlob(int columnIndex, Blob x) throws SQLException {
1867 try {
1868 this.actualResultSet.updateBlob(columnIndex, x);
1869 } catch (SQLException e) {
1870 manageException(e);
1871 throw generateException(e);
1872 }
1873 }
1874
1875 /***
1876 * @see ResultSet#updateBlob(java.lang.String, java.sql.Blob)
1877 */
1878 public void updateBlob(String columnName, Blob x) throws SQLException {
1879 try {
1880 this.actualResultSet.updateBlob(columnName, x);
1881 } catch (SQLException e) {
1882 manageException(e);
1883 throw generateException(e);
1884 }
1885 }
1886
1887 /***
1888 * @see ResultSet#updateClob(int, java.sql.Clob)
1889 */
1890 public void updateClob(int columnIndex, Clob x) throws SQLException {
1891 try {
1892 this.actualResultSet.updateClob(columnIndex, x);
1893 } catch (SQLException e) {
1894 manageException(e);
1895 throw generateException(e);
1896 }
1897 }
1898
1899 /***
1900 * @see ResultSet#updateClob(java.lang.String, java.sql.Clob)
1901 */
1902 public void updateClob(String columnName, Clob x) throws SQLException {
1903 try {
1904 this.actualResultSet.updateClob(columnName, x);
1905 } catch (SQLException e) {
1906 manageException(e);
1907 throw generateException(e);
1908 }
1909 }
1910
1911 /***
1912 * @see ResultSet#updateArray(int, java.sql.Array)
1913 */
1914 public void updateArray(int columnIndex, Array x) throws SQLException {
1915 try {
1916 this.actualResultSet.updateArray(columnIndex, x);
1917 } catch (SQLException e) {
1918 manageException(e);
1919 throw generateException(e);
1920 }
1921 }
1922
1923 /***
1924 * @see ResultSet#updateArray(java.lang.String, java.sql.Array)
1925 */
1926 public void updateArray(String columnName, Array x) throws SQLException {
1927 try {
1928 this.actualResultSet.updateArray(columnName, x);
1929 } catch (SQLException e) {
1930 manageException(e);
1931 throw generateException(e);
1932 }
1933 }
1934 }