001: package net.sourceforge.squirrel_sql.jdbcproxy;
002:
003: /*
004: * Copyright (C) 2006 Rob Manning
005: * manningr@users.sourceforge.net
006: *
007: * This library is free software; you can redistribute it and/or
008: * modify it under the terms of the GNU Lesser General Public
009: * License as published by the Free Software Foundation; either
010: * version 2.1 of the License, or (at your option) any later version.
011: *
012: * This library is distributed in the hope that it will be useful,
013: * but WITHOUT ANY WARRANTY; without even the implied warranty of
014: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
015: * Lesser General Public License for more details.
016: *
017: * You should have received a copy of the GNU Lesser General Public
018: * License along with this library; if not, write to the Free Software
019: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
020: */
021: import java.io.InputStream;
022: import java.io.Reader;
023: import java.math.BigDecimal;
024: import java.net.URL;
025: import java.sql.Array;
026: import java.sql.Blob;
027: import java.sql.Clob;
028: import java.sql.Date;
029: import java.sql.Ref;
030: import java.sql.ResultSet;
031: import java.sql.ResultSetMetaData;
032: import java.sql.SQLException;
033: import java.sql.SQLWarning;
034: import java.sql.Statement;
035: import java.sql.Time;
036: import java.sql.Timestamp;
037: import java.util.Calendar;
038: import java.util.Map;
039:
040: public class ProxyResultSet implements ResultSet {
041:
042: private ResultSet _rs = null;
043: private ProxyStatement _stmt = null;
044: private ProxyResultSetMetaData _rsmd = null;
045:
046: public ProxyResultSet(ProxyStatement stmt, ResultSet rs)
047: throws SQLException {
048: _rs = rs;
049: _stmt = stmt;
050: _rsmd = new ProxyResultSetMetaData(rs.getMetaData());
051: }
052:
053: public int getConcurrency() throws SQLException {
054: ProxyMethodManager.check("ProxyResultSet", "getConcurrency");
055: return _rs.getConcurrency();
056: }
057:
058: public int getFetchDirection() throws SQLException {
059: ProxyMethodManager.check("ProxyResultSet", "getFetchDirection");
060: return _rs.getFetchDirection();
061: }
062:
063: public int getFetchSize() throws SQLException {
064: ProxyMethodManager.check("ProxyResultSet", "getFetchSize");
065: return _rs.getFetchSize();
066: }
067:
068: public int getRow() throws SQLException {
069: ProxyMethodManager.check("ProxyResultSet", "getRow");
070: return _rs.getRow();
071: }
072:
073: public int getType() throws SQLException {
074: ProxyMethodManager.check("ProxyResultSet", "getType");
075: return _rs.getType();
076: }
077:
078: public void afterLast() throws SQLException {
079: ProxyMethodManager.check("ProxyResultSet", "afterLast");
080: _rs.afterLast();
081: }
082:
083: public void beforeFirst() throws SQLException {
084: ProxyMethodManager.check("ProxyResultSet", "beforeFirst");
085: _rs.beforeFirst();
086: }
087:
088: public void cancelRowUpdates() throws SQLException {
089: ProxyMethodManager.check("ProxyResultSet", "cancelRowUpdates");
090: _rs.cancelRowUpdates();
091: }
092:
093: public void clearWarnings() throws SQLException {
094: ProxyMethodManager.check("ProxyResultSet", "clearWarnings");
095: _rs.clearWarnings();
096: }
097:
098: public void close() throws SQLException {
099: ProxyMethodManager.check("ProxyResultSet", "close");
100: _rs.close();
101: }
102:
103: public void deleteRow() throws SQLException {
104: ProxyMethodManager.check("ProxyResultSet", "deleteRow");
105: _rs.deleteRow();
106: }
107:
108: public void insertRow() throws SQLException {
109: ProxyMethodManager.check("ProxyResultSet", "insertRow");
110: _rs.insertRow();
111: }
112:
113: public void moveToCurrentRow() throws SQLException {
114: ProxyMethodManager.check("ProxyResultSet", "moveToCurrentRow");
115: _rs.moveToCurrentRow();
116: }
117:
118: public void moveToInsertRow() throws SQLException {
119: ProxyMethodManager.check("ProxyResultSet", "moveToInsertRow");
120: _rs.moveToInsertRow();
121: }
122:
123: public void refreshRow() throws SQLException {
124: ProxyMethodManager.check("ProxyResultSet", "refreshRow");
125: _rs.refreshRow();
126: }
127:
128: public void updateRow() throws SQLException {
129: ProxyMethodManager.check("ProxyResultSet", "updateRow");
130: _rs.updateRow();
131: }
132:
133: public boolean first() throws SQLException {
134: ProxyMethodManager.check("ProxyResultSet", "first");
135: return _rs.first();
136: }
137:
138: public boolean isAfterLast() throws SQLException {
139: ProxyMethodManager.check("ProxyResultSet", "isAfterLast");
140: return _rs.isAfterLast();
141: }
142:
143: public boolean isBeforeFirst() throws SQLException {
144: ProxyMethodManager.check("ProxyResultSet", "isBeforeFirst");
145: return _rs.isBeforeFirst();
146: }
147:
148: public boolean isFirst() throws SQLException {
149: ProxyMethodManager.check("ProxyResultSet", "isFirst");
150: return _rs.isFirst();
151: }
152:
153: public boolean isLast() throws SQLException {
154: ProxyMethodManager.check("ProxyResultSet", "isLast");
155: return _rs.isLast();
156: }
157:
158: public boolean last() throws SQLException {
159: ProxyMethodManager.check("ProxyResultSet", "last");
160: return _rs.last();
161: }
162:
163: public boolean next() throws SQLException {
164: ProxyMethodManager.check("ProxyResultSet", "next");
165: return _rs.next();
166: }
167:
168: public boolean previous() throws SQLException {
169: ProxyMethodManager.check("ProxyResultSet", "previous");
170: return _rs.previous();
171: }
172:
173: public boolean rowDeleted() throws SQLException {
174: ProxyMethodManager.check("ProxyResultSet", "rowDeleted");
175: return _rs.rowDeleted();
176: }
177:
178: public boolean rowInserted() throws SQLException {
179: ProxyMethodManager.check("ProxyResultSet", "rowInserted");
180: return _rs.rowInserted();
181: }
182:
183: public boolean rowUpdated() throws SQLException {
184: ProxyMethodManager.check("ProxyResultSet", "rowUpdated");
185: return _rs.rowUpdated();
186: }
187:
188: public boolean wasNull() throws SQLException {
189: ProxyMethodManager.check("ProxyResultSet", "wasNull");
190: return _rs.wasNull();
191: }
192:
193: public byte getByte(int columnIndex) throws SQLException {
194: ProxyMethodManager.check("ProxyResultSet", "getByte");
195: return _rs.getByte(columnIndex);
196: }
197:
198: public double getDouble(int columnIndex) throws SQLException {
199: ProxyMethodManager.check("ProxyResultSet", "getDouble");
200: return _rs.getDouble(columnIndex);
201: }
202:
203: public float getFloat(int columnIndex) throws SQLException {
204: ProxyMethodManager.check("ProxyResultSet", "getFloat");
205: return _rs.getFloat(columnIndex);
206: }
207:
208: public int getInt(int columnIndex) throws SQLException {
209: ProxyMethodManager.check("ProxyResultSet", "getInt");
210: return _rs.getInt(columnIndex);
211: }
212:
213: public long getLong(int columnIndex) throws SQLException {
214: ProxyMethodManager.check("ProxyResultSet", "getLong");
215: return _rs.getLong(columnIndex);
216: }
217:
218: public short getShort(int columnIndex) throws SQLException {
219: ProxyMethodManager.check("ProxyResultSet", "getShort");
220: return _rs.getShort(columnIndex);
221: }
222:
223: public void setFetchDirection(int direction) throws SQLException {
224: ProxyMethodManager.check("ProxyResultSet", "setFetchDirection");
225: _rs.setFetchDirection(direction);
226: }
227:
228: public void setFetchSize(int rows) throws SQLException {
229: ProxyMethodManager.check("ProxyResultSet", "setFetchSize");
230: _rs.setFetchSize(rows);
231: }
232:
233: public void updateNull(int columnIndex) throws SQLException {
234: ProxyMethodManager.check("ProxyResultSet", "updateNull");
235: _rs.updateNull(columnIndex);
236: }
237:
238: public boolean absolute(int row) throws SQLException {
239: ProxyMethodManager.check("ProxyResultSet", "absolute");
240: return _rs.absolute(row);
241: }
242:
243: public boolean getBoolean(int columnIndex) throws SQLException {
244: ProxyMethodManager.check("ProxyResultSet", "getBoolean");
245: return _rs.getBoolean(columnIndex);
246: }
247:
248: public boolean relative(int rows) throws SQLException {
249: ProxyMethodManager.check("ProxyResultSet", "relative");
250: return _rs.relative(rows);
251: }
252:
253: public byte[] getBytes(int columnIndex) throws SQLException {
254: ProxyMethodManager.check("ProxyResultSet", "getBytes");
255: return _rs.getBytes(columnIndex);
256: }
257:
258: public void updateByte(int columnIndex, byte x) throws SQLException {
259: ProxyMethodManager.check("ProxyResultSet", "updateByte");
260: _rs.updateByte(columnIndex, x);
261: }
262:
263: public void updateDouble(int columnIndex, double x)
264: throws SQLException {
265: ProxyMethodManager.check("ProxyResultSet", "updateDouble");
266: _rs.updateDouble(columnIndex, x);
267: }
268:
269: public void updateFloat(int columnIndex, float x)
270: throws SQLException {
271: ProxyMethodManager.check("ProxyResultSet", "updateFloat");
272: _rs.updateFloat(columnIndex, x);
273: }
274:
275: public void updateInt(int columnIndex, int x) throws SQLException {
276: ProxyMethodManager.check("ProxyResultSet", "updateInt");
277: _rs.updateInt(columnIndex, x);
278: }
279:
280: public void updateLong(int columnIndex, long x) throws SQLException {
281: ProxyMethodManager.check("ProxyResultSet", "updateLong");
282: _rs.updateLong(columnIndex, x);
283: }
284:
285: public void updateShort(int columnIndex, short x)
286: throws SQLException {
287: ProxyMethodManager.check("ProxyResultSet", "updateShort");
288: _rs.updateShort(columnIndex, x);
289: }
290:
291: public void updateBoolean(int columnIndex, boolean x)
292: throws SQLException {
293: ProxyMethodManager.check("ProxyResultSet", "updateBoolean");
294: _rs.updateBoolean(columnIndex, x);
295: }
296:
297: public void updateBytes(int columnIndex, byte[] x)
298: throws SQLException {
299: ProxyMethodManager.check("ProxyResultSet", "updateBytes");
300: _rs.updateBytes(columnIndex, x);
301: }
302:
303: public InputStream getAsciiStream(int columnIndex)
304: throws SQLException {
305: ProxyMethodManager.check("ProxyResultSet", "getAsciiStream");
306: return _rs.getAsciiStream(columnIndex);
307: }
308:
309: public InputStream getBinaryStream(int columnIndex)
310: throws SQLException {
311: ProxyMethodManager.check("ProxyResultSet", "getBinaryStream");
312: return _rs.getBinaryStream(columnIndex);
313: }
314:
315: @SuppressWarnings("deprecation")
316: public InputStream getUnicodeStream(int columnIndex)
317: throws SQLException {
318: ProxyMethodManager.check("ProxyResultSet", "getUnicodeStream");
319: return _rs.getUnicodeStream(columnIndex);
320: }
321:
322: public void updateAsciiStream(int columnIndex, InputStream x,
323: int length) throws SQLException {
324: ProxyMethodManager.check("ProxyResultSet", "updateAsciiStream");
325: _rs.updateAsciiStream(columnIndex, x, length);
326: }
327:
328: public void updateBinaryStream(int columnIndex, InputStream x,
329: int length) throws SQLException {
330: ProxyMethodManager
331: .check("ProxyResultSet", "updateBinaryStream");
332: _rs.updateBinaryStream(columnIndex, x, length);
333: }
334:
335: public Reader getCharacterStream(int columnIndex)
336: throws SQLException {
337: ProxyMethodManager
338: .check("ProxyResultSet", "getCharacterStream");
339: return _rs.getCharacterStream(columnIndex);
340: }
341:
342: public void updateCharacterStream(int columnIndex, Reader x,
343: int length) throws SQLException {
344: ProxyMethodManager.check("ProxyResultSet",
345: "updateCharacterStream");
346: _rs.updateCharacterStream(columnIndex, x, length);
347: }
348:
349: public Object getObject(int columnIndex) throws SQLException {
350: ProxyMethodManager.check("ProxyResultSet", "getObject");
351: return _rs.getObject(columnIndex);
352: }
353:
354: public void updateObject(int columnIndex, Object x)
355: throws SQLException {
356: ProxyMethodManager.check("ProxyResultSet", "updateObject");
357: _rs.updateObject(columnIndex, x);
358: }
359:
360: public void updateObject(int columnIndex, Object x, int scale)
361: throws SQLException {
362: ProxyMethodManager.check("ProxyResultSet", "updateObject");
363: _rs.updateObject(columnIndex, x, scale);
364: }
365:
366: public String getCursorName() throws SQLException {
367: ProxyMethodManager.check("ProxyResultSet", "getCursorName");
368: return _rs.getCursorName();
369: }
370:
371: public String getString(int columnIndex) throws SQLException {
372: ProxyMethodManager.check("ProxyResultSet", "getString");
373: return _rs.getString(columnIndex);
374: }
375:
376: public void updateString(int columnIndex, String x)
377: throws SQLException {
378: ProxyMethodManager.check("ProxyResultSet", "updateString");
379: _rs.updateString(columnIndex, x);
380: }
381:
382: public byte getByte(String columnName) throws SQLException {
383: ProxyMethodManager.check("ProxyResultSet", "getByte");
384: return _rs.getByte(columnName);
385: }
386:
387: public double getDouble(String columnName) throws SQLException {
388: ProxyMethodManager.check("ProxyResultSet", "getDouble");
389: return _rs.getDouble(columnName);
390: }
391:
392: public float getFloat(String columnName) throws SQLException {
393: ProxyMethodManager.check("ProxyResultSet", "getFloat");
394: return _rs.getFloat(columnName);
395: }
396:
397: public int findColumn(String columnName) throws SQLException {
398: ProxyMethodManager.check("ProxyResultSet", "findColumn");
399: return _rs.findColumn(columnName);
400: }
401:
402: public int getInt(String columnName) throws SQLException {
403: ProxyMethodManager.check("ProxyResultSet", "getInt");
404: return _rs.getInt(columnName);
405: }
406:
407: public long getLong(String columnName) throws SQLException {
408: ProxyMethodManager.check("ProxyResultSet", "getLong");
409: return _rs.getLong(columnName);
410: }
411:
412: public short getShort(String columnName) throws SQLException {
413: ProxyMethodManager.check("ProxyResultSet", "getShort");
414: return _rs.getShort(columnName);
415: }
416:
417: public void updateNull(String columnName) throws SQLException {
418: ProxyMethodManager.check("ProxyResultSet", "updateNull");
419: _rs.updateNull(columnName);
420: }
421:
422: public boolean getBoolean(String columnName) throws SQLException {
423: ProxyMethodManager.check("ProxyResultSet", "getBoolean");
424: return _rs.getBoolean(columnName);
425: }
426:
427: public byte[] getBytes(String columnName) throws SQLException {
428: ProxyMethodManager.check("ProxyResultSet", "getBytes");
429: return _rs.getBytes(columnName);
430: }
431:
432: public void updateByte(String columnName, byte x)
433: throws SQLException {
434: ProxyMethodManager.check("ProxyResultSet", "updateByte");
435: _rs.updateByte(columnName, x);
436: }
437:
438: public void updateDouble(String columnName, double x)
439: throws SQLException {
440: ProxyMethodManager.check("ProxyResultSet", "updateDouble");
441: _rs.updateDouble(columnName, x);
442: }
443:
444: public void updateFloat(String columnName, float x)
445: throws SQLException {
446: ProxyMethodManager.check("ProxyResultSet", "updateFloat");
447: _rs.updateFloat(columnName, x);
448: }
449:
450: public void updateInt(String columnName, int x) throws SQLException {
451: ProxyMethodManager.check("ProxyResultSet", "updateInt");
452: _rs.updateInt(columnName, x);
453: }
454:
455: public void updateLong(String columnName, long x)
456: throws SQLException {
457: ProxyMethodManager.check("ProxyResultSet", "updateLong");
458: _rs.updateLong(columnName, x);
459: }
460:
461: public void updateShort(String columnName, short x)
462: throws SQLException {
463: ProxyMethodManager.check("ProxyResultSet", "updateShort");
464: _rs.updateShort(columnName, x);
465: }
466:
467: public void updateBoolean(String columnName, boolean x)
468: throws SQLException {
469: ProxyMethodManager.check("ProxyResultSet", "updateBoolean");
470: _rs.updateBoolean(columnName, x);
471: }
472:
473: public void updateBytes(String columnName, byte[] x)
474: throws SQLException {
475: ProxyMethodManager.check("ProxyResultSet", "updateBytes");
476: _rs.updateBytes(columnName, x);
477: }
478:
479: public BigDecimal getBigDecimal(int columnIndex)
480: throws SQLException {
481: ProxyMethodManager.check("ProxyResultSet", "getBigDecimal");
482: return _rs.getBigDecimal(columnIndex);
483: }
484:
485: public BigDecimal getBigDecimal(int columnIndex, int scale)
486: throws SQLException {
487: ProxyMethodManager.check("ProxyResultSet", "getBigDecimal");
488: return _rs.getBigDecimal(columnIndex);
489: }
490:
491: public void updateBigDecimal(int columnIndex, BigDecimal x)
492: throws SQLException {
493: ProxyMethodManager.check("ProxyResultSet", "updateBigDecimal");
494: _rs.updateBigDecimal(columnIndex, x);
495: }
496:
497: public URL getURL(int columnIndex) throws SQLException {
498: ProxyMethodManager.check("ProxyResultSet", "getURL");
499: return _rs.getURL(columnIndex);
500: }
501:
502: public Array getArray(int i) throws SQLException {
503: ProxyMethodManager.check("ProxyResultSet", "getArray");
504: return _rs.getArray(i);
505: }
506:
507: public void updateArray(int columnIndex, Array x)
508: throws SQLException {
509: ProxyMethodManager.check("ProxyResultSet", "updateArray");
510: _rs.updateArray(columnIndex, x);
511: }
512:
513: public Blob getBlob(int i) throws SQLException {
514: ProxyMethodManager.check("ProxyResultSet", "getBlob");
515: return _rs.getBlob(i);
516: }
517:
518: public void updateBlob(int columnIndex, Blob x) throws SQLException {
519: ProxyMethodManager.check("ProxyResultSet", "updateBlob");
520: _rs.updateBlob(columnIndex, x);
521: }
522:
523: public Clob getClob(int i) throws SQLException {
524: ProxyMethodManager.check("ProxyResultSet", "getClob");
525: return _rs.getClob(i);
526: }
527:
528: public void updateClob(int columnIndex, Clob x) throws SQLException {
529: ProxyMethodManager.check("ProxyResultSet", "updateClob");
530: _rs.updateClob(columnIndex, x);
531: }
532:
533: public Date getDate(int columnIndex) throws SQLException {
534: ProxyMethodManager.check("ProxyResultSet", "getDate");
535: return _rs.getDate(columnIndex);
536: }
537:
538: public void updateDate(int columnIndex, Date x) throws SQLException {
539: ProxyMethodManager.check("ProxyResultSet", "updateDate");
540: _rs.updateDate(columnIndex, x);
541: }
542:
543: public Ref getRef(int i) throws SQLException {
544: ProxyMethodManager.check("ProxyResultSet", "getRef");
545: return _rs.getRef(i);
546: }
547:
548: public void updateRef(int columnIndex, Ref x) throws SQLException {
549: ProxyMethodManager.check("ProxyResultSet", "updateRef");
550: _rs.updateRef(columnIndex, x);
551: }
552:
553: public ResultSetMetaData getMetaData() throws SQLException {
554: ProxyMethodManager.check("ProxyResultSet", "getMetaData");
555: return _rsmd;
556: }
557:
558: public SQLWarning getWarnings() throws SQLException {
559: ProxyMethodManager.check("ProxyResultSet", "getWarnings");
560: return _rs.getWarnings();
561: }
562:
563: public Statement getStatement() throws SQLException {
564: ProxyMethodManager.check("ProxyResultSet", "getStatement");
565: return _stmt;
566: }
567:
568: public Time getTime(int columnIndex) throws SQLException {
569: ProxyMethodManager.check("ProxyResultSet", "getTime");
570: return _rs.getTime(columnIndex);
571: }
572:
573: public void updateTime(int columnIndex, Time x) throws SQLException {
574: ProxyMethodManager.check("ProxyResultSet", "updateTime");
575: _rs.updateTime(columnIndex, x);
576: }
577:
578: public Timestamp getTimestamp(int columnIndex) throws SQLException {
579: ProxyMethodManager.check("ProxyResultSet", "getTimestamp");
580: return _rs.getTimestamp(columnIndex);
581: }
582:
583: public void updateTimestamp(int columnIndex, Timestamp x)
584: throws SQLException {
585: ProxyMethodManager.check("ProxyResultSet", "updateTimestamp");
586: _rs.updateTimestamp(columnIndex, x);
587: }
588:
589: public InputStream getAsciiStream(String columnName)
590: throws SQLException {
591: ProxyMethodManager.check("ProxyResultSet", "getAsciiStream");
592: return _rs.getAsciiStream(columnName);
593: }
594:
595: public InputStream getBinaryStream(String columnName)
596: throws SQLException {
597: ProxyMethodManager.check("ProxyResultSet", "getBinaryStream");
598: return _rs.getBinaryStream(columnName);
599: }
600:
601: @SuppressWarnings("deprecation")
602: public InputStream getUnicodeStream(String columnName)
603: throws SQLException {
604: ProxyMethodManager.check("ProxyResultSet", "getUnicodeStream");
605: return _rs.getUnicodeStream(columnName);
606: }
607:
608: public void updateAsciiStream(String columnName, InputStream x,
609: int length) throws SQLException {
610: ProxyMethodManager.check("ProxyResultSet", "updateAsciiStream");
611: _rs.updateAsciiStream(columnName, x, length);
612: }
613:
614: public void updateBinaryStream(String columnName, InputStream x,
615: int length) throws SQLException {
616: ProxyMethodManager
617: .check("ProxyResultSet", "updateBinaryStream");
618: _rs.updateBinaryStream(columnName, x, length);
619: }
620:
621: public Reader getCharacterStream(String columnName)
622: throws SQLException {
623: ProxyMethodManager
624: .check("ProxyResultSet", "getCharacterStream");
625: return _rs.getCharacterStream(columnName);
626: }
627:
628: public void updateCharacterStream(String columnName, Reader reader,
629: int length) throws SQLException {
630: ProxyMethodManager.check("ProxyResultSet",
631: "updateCharacterStream");
632: _rs.updateCharacterStream(columnName, reader, length);
633: }
634:
635: public Object getObject(String columnName) throws SQLException {
636: ProxyMethodManager.check("ProxyResultSet", "getObject");
637: return _rs.getObject(columnName);
638: }
639:
640: public void updateObject(String columnName, Object x)
641: throws SQLException {
642: ProxyMethodManager.check("ProxyResultSet", "updateObject");
643: _rs.updateObject(columnName, x);
644: }
645:
646: public void updateObject(String columnName, Object x, int scale)
647: throws SQLException {
648: ProxyMethodManager.check("ProxyResultSet", "updateObject");
649: _rs.updateObject(columnName, x);
650: }
651:
652: @SuppressWarnings("unchecked")
653: public Object getObject(int i, Map map) throws SQLException {
654: ProxyMethodManager.check("ProxyResultSet", "getObject");
655: return _rs.getObject(i, map);
656: }
657:
658: public String getString(String columnName) throws SQLException {
659: ProxyMethodManager.check("ProxyResultSet", "getString");
660: return _rs.getString(columnName);
661: }
662:
663: public void updateString(String columnName, String x)
664: throws SQLException {
665: ProxyMethodManager.check("ProxyResultSet", "updateString");
666: _rs.updateString(columnName, x);
667: }
668:
669: public BigDecimal getBigDecimal(String columnName)
670: throws SQLException {
671: ProxyMethodManager.check("ProxyResultSet", "getBigDecimal");
672: return _rs.getBigDecimal(columnName);
673: }
674:
675: @SuppressWarnings("deprecation")
676: public BigDecimal getBigDecimal(String columnName, int scale)
677: throws SQLException {
678: ProxyMethodManager.check("ProxyResultSet", "getBigDecimal");
679: return _rs.getBigDecimal(columnName);
680: }
681:
682: public void updateBigDecimal(String columnName, BigDecimal x)
683: throws SQLException {
684: ProxyMethodManager.check("ProxyResultSet", "updateBigDecimal");
685: _rs.updateBigDecimal(columnName, x);
686: }
687:
688: public URL getURL(String columnName) throws SQLException {
689: ProxyMethodManager.check("ProxyResultSet", "getURL");
690: return _rs.getURL(columnName);
691: }
692:
693: public Array getArray(String colName) throws SQLException {
694: ProxyMethodManager.check("ProxyResultSet", "getArray");
695: return _rs.getArray(colName);
696: }
697:
698: public void updateArray(String columnName, Array x)
699: throws SQLException {
700: ProxyMethodManager.check("ProxyResultSet", "updateArray");
701: _rs.updateArray(columnName, x);
702: }
703:
704: public Blob getBlob(String colName) throws SQLException {
705: ProxyMethodManager.check("ProxyResultSet", "getBlob");
706: return _rs.getBlob(colName);
707: }
708:
709: public void updateBlob(String columnName, Blob x)
710: throws SQLException {
711: ProxyMethodManager.check("ProxyResultSet", "updateBlob");
712: _rs.updateBlob(columnName, x);
713: }
714:
715: public Clob getClob(String colName) throws SQLException {
716: ProxyMethodManager.check("ProxyResultSet", "getClob");
717: return _rs.getClob(colName);
718: }
719:
720: public void updateClob(String columnName, Clob x)
721: throws SQLException {
722: ProxyMethodManager.check("ProxyResultSet", "updateClob");
723: _rs.updateClob(columnName, x);
724: }
725:
726: public Date getDate(String columnName) throws SQLException {
727: ProxyMethodManager.check("ProxyResultSet", "getDate");
728: return _rs.getDate(columnName);
729: }
730:
731: public void updateDate(String columnName, Date x)
732: throws SQLException {
733: ProxyMethodManager.check("ProxyResultSet", "updateDate");
734: _rs.updateDate(columnName, x);
735: }
736:
737: public Date getDate(int columnIndex, Calendar cal)
738: throws SQLException {
739: ProxyMethodManager.check("ProxyResultSet", "getDate");
740: return _rs.getDate(columnIndex, cal);
741: }
742:
743: public Ref getRef(String colName) throws SQLException {
744: ProxyMethodManager.check("ProxyResultSet", "getRef");
745: return _rs.getRef(colName);
746: }
747:
748: public void updateRef(String columnName, Ref x) throws SQLException {
749: ProxyMethodManager.check("ProxyResultSet", "updateRef");
750: _rs.updateRef(columnName, x);
751: }
752:
753: public Time getTime(String columnName) throws SQLException {
754: ProxyMethodManager.check("ProxyResultSet", "getTime");
755: return _rs.getTime(columnName);
756: }
757:
758: public void updateTime(String columnName, Time x)
759: throws SQLException {
760: ProxyMethodManager.check("ProxyResultSet", "updateTime");
761: _rs.updateTime(columnName, x);
762: }
763:
764: public Time getTime(int columnIndex, Calendar cal)
765: throws SQLException {
766: ProxyMethodManager.check("ProxyResultSet", "getTime");
767: return _rs.getTime(columnIndex, cal);
768: }
769:
770: public Timestamp getTimestamp(String columnName)
771: throws SQLException {
772: ProxyMethodManager.check("ProxyResultSet", "getTimestamp");
773: return _rs.getTimestamp(columnName);
774: }
775:
776: public void updateTimestamp(String columnName, Timestamp x)
777: throws SQLException {
778: ProxyMethodManager.check("ProxyResultSet", "updateTimestamp");
779: _rs.updateTimestamp(columnName, x);
780: }
781:
782: public Timestamp getTimestamp(int columnIndex, Calendar cal)
783: throws SQLException {
784: ProxyMethodManager.check("ProxyResultSet", "getTimestamp");
785: return _rs.getTimestamp(columnIndex, cal);
786: }
787:
788: @SuppressWarnings("unchecked")
789: public Object getObject(String colName, Map map)
790: throws SQLException {
791: ProxyMethodManager.check("ProxyResultSet", "getObject");
792: return _rs.getObject(colName, map);
793: }
794:
795: public Date getDate(String columnName, Calendar cal)
796: throws SQLException {
797: ProxyMethodManager.check("ProxyResultSet", "getDate");
798: return _rs.getDate(columnName, cal);
799: }
800:
801: public Time getTime(String columnName, Calendar cal)
802: throws SQLException {
803: ProxyMethodManager.check("ProxyResultSet", "getTime");
804: return _rs.getTime(columnName, cal);
805: }
806:
807: public Timestamp getTimestamp(String columnName, Calendar cal)
808: throws SQLException {
809: ProxyMethodManager.check("ProxyResultSet", "getTimestamp");
810: return _rs.getTimestamp(columnName, cal);
811: }
812: }
|