001package com.randomnoun.common.db;
002
003import java.io.InputStream;
004import java.io.Reader;
005import java.math.BigDecimal;
006import java.net.URL;
007import java.sql.Array;
008import java.sql.Blob;
009import java.sql.Clob;
010import java.sql.Date;
011import java.sql.NClob;
012import java.sql.Ref;
013import java.sql.ResultSet;
014import java.sql.ResultSetMetaData;
015import java.sql.RowId;
016import java.sql.SQLException;
017import java.sql.SQLType;
018import java.sql.SQLWarning;
019import java.sql.SQLXML;
020import java.sql.Statement;
021import java.sql.Time;
022import java.sql.Timestamp;
023import java.util.Calendar;
024import java.util.Map;
025
026/** A class which wraps a ResultSet that makes it easier to handle nullable columns.
027 * 
028 * <p>Instead of calling wasNull() after each nullable column, this class will do that for you and return a null instead.
029 * 
030 * <p>Use the getXxxxOrNull() methods in this class to get the new behaviour.
031 * 
032 */
033public class ResultSetWithNulls implements ResultSet {
034
035        private ResultSet rs;
036
037        public ResultSetWithNulls(ResultSet wrappedResultSet) {
038                this.rs = wrappedResultSet;
039        }
040        
041        /** these are the new methods */
042        
043        Boolean getBooleanOrNull(int columnIndex) throws SQLException {
044                boolean b = getBoolean(columnIndex);
045                return wasNull() ? null : b;
046        }
047
048        Byte getByteOrNull(int columnIndex) throws SQLException {
049                byte b = getByte(columnIndex);
050                return wasNull() ? null : b;
051        }
052
053        Short getShortOrNull(int columnIndex) throws SQLException {
054                short b = getShort(columnIndex);
055                return wasNull() ? null : b;
056        }
057
058        Integer getIntOrNull(int columnIndex) throws SQLException {
059                int b = getInt(columnIndex);
060                return wasNull() ? null : b;
061        }
062
063        Long getLongOrNull(int columnIndex) throws SQLException {
064                long b = getLong(columnIndex);
065                return wasNull() ? null : b;
066        }
067
068        Float getFloatOrNull(int columnIndex) throws SQLException {
069                float b = getFloat(columnIndex);
070                return wasNull() ? null : b;
071        }
072
073        Double getDoubleOrNull(int columnIndex) throws SQLException {
074                double b = getDouble(columnIndex);
075                return wasNull() ? null : b;
076        }
077
078        Boolean getBooleanOrNull(String columnLabel) throws SQLException {
079                boolean b = getBoolean(columnLabel);
080                return wasNull() ? null : b;
081        }
082
083        Byte getByteOrNull(String columnLabel) throws SQLException {
084                byte b = getByte(columnLabel);
085                return wasNull() ? null : b;
086        }
087
088        Short getShortOrNull(String columnLabel) throws SQLException {
089                short b = getShort(columnLabel);
090                return wasNull() ? null : b;
091        }
092
093        Integer getIntOrNull(String columnLabel) throws SQLException {
094                int b = getInt(columnLabel);
095                return wasNull() ? null : b;
096        }
097
098        Long getLongOrNull(String columnLabel) throws SQLException {
099                long b = getLong(columnLabel);
100                return wasNull() ? null : b;
101        }
102
103        Float getFloatOrNull(String columnLabel) throws SQLException {
104                float b = getFloat(columnLabel);
105                return wasNull() ? null : b;
106        }
107
108        Double getDoubleOrNull(String columnLabel) throws SQLException {
109                double b = getDouble(columnLabel);
110                return wasNull() ? null : b;
111        }
112        
113        
114        /** Automatically generated methods */
115        
116        public <T> T unwrap(Class<T> iface) throws SQLException {
117                return rs.unwrap(iface);
118        }
119
120        public boolean isWrapperFor(Class<?> iface) throws SQLException {
121                return rs.isWrapperFor(iface);
122        }
123
124        public boolean next() throws SQLException {
125                return rs.next();
126        }
127
128        public void close() throws SQLException {
129                rs.close();
130        }
131
132        public boolean wasNull() throws SQLException {
133                return rs.wasNull();
134        }
135
136        public String getString(int columnIndex) throws SQLException {
137                return rs.getString(columnIndex);
138        }
139
140        public boolean getBoolean(int columnIndex) throws SQLException {
141                return rs.getBoolean(columnIndex);
142        }
143
144        public byte getByte(int columnIndex) throws SQLException {
145                return rs.getByte(columnIndex);
146        }
147
148        public short getShort(int columnIndex) throws SQLException {
149                return rs.getShort(columnIndex);
150        }
151
152        public int getInt(int columnIndex) throws SQLException {
153                return rs.getInt(columnIndex);
154        }
155
156        public long getLong(int columnIndex) throws SQLException {
157                return rs.getLong(columnIndex);
158        }
159
160        public float getFloat(int columnIndex) throws SQLException {
161                return rs.getFloat(columnIndex);
162        }
163
164        public double getDouble(int columnIndex) throws SQLException {
165                return rs.getDouble(columnIndex);
166        }
167
168        /** @deprecated */
169        public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
170                return rs.getBigDecimal(columnIndex, scale);
171        }
172
173        public byte[] getBytes(int columnIndex) throws SQLException {
174                return rs.getBytes(columnIndex);
175        }
176
177        public Date getDate(int columnIndex) throws SQLException {
178                return rs.getDate(columnIndex);
179        }
180
181        public Time getTime(int columnIndex) throws SQLException {
182                return rs.getTime(columnIndex);
183        }
184
185        public Timestamp getTimestamp(int columnIndex) throws SQLException {
186                return rs.getTimestamp(columnIndex);
187        }
188
189        public InputStream getAsciiStream(int columnIndex) throws SQLException {
190                return rs.getAsciiStream(columnIndex);
191        }
192
193        /** @deprecated */
194        public InputStream getUnicodeStream(int columnIndex) throws SQLException {
195                return rs.getUnicodeStream(columnIndex);
196        }
197
198        public InputStream getBinaryStream(int columnIndex) throws SQLException {
199                return rs.getBinaryStream(columnIndex);
200        }
201
202        public String getString(String columnLabel) throws SQLException {
203                return rs.getString(columnLabel);
204        }
205
206        public boolean getBoolean(String columnLabel) throws SQLException {
207                return rs.getBoolean(columnLabel);
208        }
209
210        public byte getByte(String columnLabel) throws SQLException {
211                return rs.getByte(columnLabel);
212        }
213
214        public short getShort(String columnLabel) throws SQLException {
215                return rs.getShort(columnLabel);
216        }
217
218        public int getInt(String columnLabel) throws SQLException {
219                return rs.getInt(columnLabel);
220        }
221
222        public long getLong(String columnLabel) throws SQLException {
223                return rs.getLong(columnLabel);
224        }
225
226        public float getFloat(String columnLabel) throws SQLException {
227                return rs.getFloat(columnLabel);
228        }
229
230        public double getDouble(String columnLabel) throws SQLException {
231                return rs.getDouble(columnLabel);
232        }
233
234        /** @deprecated */
235        public BigDecimal getBigDecimal(String columnLabel, int scale) throws SQLException {
236                return rs.getBigDecimal(columnLabel, scale);
237        }
238
239        public byte[] getBytes(String columnLabel) throws SQLException {
240                return rs.getBytes(columnLabel);
241        }
242
243        public Date getDate(String columnLabel) throws SQLException {
244                return rs.getDate(columnLabel);
245        }
246
247        public Time getTime(String columnLabel) throws SQLException {
248                return rs.getTime(columnLabel);
249        }
250
251        public Timestamp getTimestamp(String columnLabel) throws SQLException {
252                return rs.getTimestamp(columnLabel);
253        }
254
255        public InputStream getAsciiStream(String columnLabel) throws SQLException {
256                return rs.getAsciiStream(columnLabel);
257        }
258
259        /** @deprecated */
260        public InputStream getUnicodeStream(String columnLabel) throws SQLException {
261                return rs.getUnicodeStream(columnLabel);
262        }
263
264        public InputStream getBinaryStream(String columnLabel) throws SQLException {
265                return rs.getBinaryStream(columnLabel);
266        }
267
268        public SQLWarning getWarnings() throws SQLException {
269                return rs.getWarnings();
270        }
271
272        public void clearWarnings() throws SQLException {
273                rs.clearWarnings();
274        }
275
276        public String getCursorName() throws SQLException {
277                return rs.getCursorName();
278        }
279
280        public ResultSetMetaData getMetaData() throws SQLException {
281                return rs.getMetaData();
282        }
283
284        public Object getObject(int columnIndex) throws SQLException {
285                return rs.getObject(columnIndex);
286        }
287
288        public Object getObject(String columnLabel) throws SQLException {
289                return rs.getObject(columnLabel);
290        }
291
292        public int findColumn(String columnLabel) throws SQLException {
293                return rs.findColumn(columnLabel);
294        }
295
296        public Reader getCharacterStream(int columnIndex) throws SQLException {
297                return rs.getCharacterStream(columnIndex);
298        }
299
300        public Reader getCharacterStream(String columnLabel) throws SQLException {
301                return rs.getCharacterStream(columnLabel);
302        }
303
304        public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
305                return rs.getBigDecimal(columnIndex);
306        }
307
308        public BigDecimal getBigDecimal(String columnLabel) throws SQLException {
309                return rs.getBigDecimal(columnLabel);
310        }
311
312        public boolean isBeforeFirst() throws SQLException {
313                return rs.isBeforeFirst();
314        }
315
316        public boolean isAfterLast() throws SQLException {
317                return rs.isAfterLast();
318        }
319
320        public boolean isFirst() throws SQLException {
321                return rs.isFirst();
322        }
323
324        public boolean isLast() throws SQLException {
325                return rs.isLast();
326        }
327
328        public void beforeFirst() throws SQLException {
329                rs.beforeFirst();
330        }
331
332        public void afterLast() throws SQLException {
333                rs.afterLast();
334        }
335
336        public boolean first() throws SQLException {
337                return rs.first();
338        }
339
340        public boolean last() throws SQLException {
341                return rs.last();
342        }
343
344        public int getRow() throws SQLException {
345                return rs.getRow();
346        }
347
348        public boolean absolute(int row) throws SQLException {
349                return rs.absolute(row);
350        }
351
352        public boolean relative(int rows) throws SQLException {
353                return rs.relative(rows);
354        }
355
356        public boolean previous() throws SQLException {
357                return rs.previous();
358        }
359
360        public void setFetchDirection(int direction) throws SQLException {
361                rs.setFetchDirection(direction);
362        }
363
364        public int getFetchDirection() throws SQLException {
365                return rs.getFetchDirection();
366        }
367
368        public void setFetchSize(int rows) throws SQLException {
369                rs.setFetchSize(rows);
370        }
371
372        public int getFetchSize() throws SQLException {
373                return rs.getFetchSize();
374        }
375
376        public int getType() throws SQLException {
377                return rs.getType();
378        }
379
380        public int getConcurrency() throws SQLException {
381                return rs.getConcurrency();
382        }
383
384        public boolean rowUpdated() throws SQLException {
385                return rs.rowUpdated();
386        }
387
388        public boolean rowInserted() throws SQLException {
389                return rs.rowInserted();
390        }
391
392        public boolean rowDeleted() throws SQLException {
393                return rs.rowDeleted();
394        }
395
396        public void updateNull(int columnIndex) throws SQLException {
397                rs.updateNull(columnIndex);
398        }
399
400        public void updateBoolean(int columnIndex, boolean x) throws SQLException {
401                rs.updateBoolean(columnIndex, x);
402        }
403
404        public void updateByte(int columnIndex, byte x) throws SQLException {
405                rs.updateByte(columnIndex, x);
406        }
407
408        public void updateShort(int columnIndex, short x) throws SQLException {
409                rs.updateShort(columnIndex, x);
410        }
411
412        public void updateInt(int columnIndex, int x) throws SQLException {
413                rs.updateInt(columnIndex, x);
414        }
415
416        public void updateLong(int columnIndex, long x) throws SQLException {
417                rs.updateLong(columnIndex, x);
418        }
419
420        public void updateFloat(int columnIndex, float x) throws SQLException {
421                rs.updateFloat(columnIndex, x);
422        }
423
424        public void updateDouble(int columnIndex, double x) throws SQLException {
425                rs.updateDouble(columnIndex, x);
426        }
427
428        public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException {
429                rs.updateBigDecimal(columnIndex, x);
430        }
431
432        public void updateString(int columnIndex, String x) throws SQLException {
433                rs.updateString(columnIndex, x);
434        }
435
436        public void updateBytes(int columnIndex, byte[] x) throws SQLException {
437                rs.updateBytes(columnIndex, x);
438        }
439
440        public void updateDate(int columnIndex, Date x) throws SQLException {
441                rs.updateDate(columnIndex, x);
442        }
443
444        public void updateTime(int columnIndex, Time x) throws SQLException {
445                rs.updateTime(columnIndex, x);
446        }
447
448        public void updateTimestamp(int columnIndex, Timestamp x) throws SQLException {
449                rs.updateTimestamp(columnIndex, x);
450        }
451
452        public void updateAsciiStream(int columnIndex, InputStream x, int length) throws SQLException {
453                rs.updateAsciiStream(columnIndex, x, length);
454        }
455
456        public void updateBinaryStream(int columnIndex, InputStream x, int length) throws SQLException {
457                rs.updateBinaryStream(columnIndex, x, length);
458        }
459
460        public void updateCharacterStream(int columnIndex, Reader x, int length) throws SQLException {
461                rs.updateCharacterStream(columnIndex, x, length);
462        }
463
464        public void updateObject(int columnIndex, Object x, int scaleOrLength) throws SQLException {
465                rs.updateObject(columnIndex, x, scaleOrLength);
466        }
467
468        public void updateObject(int columnIndex, Object x) throws SQLException {
469                rs.updateObject(columnIndex, x);
470        }
471
472        public void updateNull(String columnLabel) throws SQLException {
473                rs.updateNull(columnLabel);
474        }
475
476        public void updateBoolean(String columnLabel, boolean x) throws SQLException {
477                rs.updateBoolean(columnLabel, x);
478        }
479
480        public void updateByte(String columnLabel, byte x) throws SQLException {
481                rs.updateByte(columnLabel, x);
482        }
483
484        public void updateShort(String columnLabel, short x) throws SQLException {
485                rs.updateShort(columnLabel, x);
486        }
487
488        public void updateInt(String columnLabel, int x) throws SQLException {
489                rs.updateInt(columnLabel, x);
490        }
491
492        public void updateLong(String columnLabel, long x) throws SQLException {
493                rs.updateLong(columnLabel, x);
494        }
495
496        public void updateFloat(String columnLabel, float x) throws SQLException {
497                rs.updateFloat(columnLabel, x);
498        }
499
500        public void updateDouble(String columnLabel, double x) throws SQLException {
501                rs.updateDouble(columnLabel, x);
502        }
503
504        public void updateBigDecimal(String columnLabel, BigDecimal x) throws SQLException {
505                rs.updateBigDecimal(columnLabel, x);
506        }
507
508        public void updateString(String columnLabel, String x) throws SQLException {
509                rs.updateString(columnLabel, x);
510        }
511
512        public void updateBytes(String columnLabel, byte[] x) throws SQLException {
513                rs.updateBytes(columnLabel, x);
514        }
515
516        public void updateDate(String columnLabel, Date x) throws SQLException {
517                rs.updateDate(columnLabel, x);
518        }
519
520        public void updateTime(String columnLabel, Time x) throws SQLException {
521                rs.updateTime(columnLabel, x);
522        }
523
524        public void updateTimestamp(String columnLabel, Timestamp x) throws SQLException {
525                rs.updateTimestamp(columnLabel, x);
526        }
527
528        public void updateAsciiStream(String columnLabel, InputStream x, int length) throws SQLException {
529                rs.updateAsciiStream(columnLabel, x, length);
530        }
531
532        public void updateBinaryStream(String columnLabel, InputStream x, int length) throws SQLException {
533                rs.updateBinaryStream(columnLabel, x, length);
534        }
535
536        public void updateCharacterStream(String columnLabel, Reader reader, int length) throws SQLException {
537                rs.updateCharacterStream(columnLabel, reader, length);
538        }
539
540        public void updateObject(String columnLabel, Object x, int scaleOrLength) throws SQLException {
541                rs.updateObject(columnLabel, x, scaleOrLength);
542        }
543
544        public void updateObject(String columnLabel, Object x) throws SQLException {
545                rs.updateObject(columnLabel, x);
546        }
547
548        public void insertRow() throws SQLException {
549                rs.insertRow();
550        }
551
552        public void updateRow() throws SQLException {
553                rs.updateRow();
554        }
555
556        public void deleteRow() throws SQLException {
557                rs.deleteRow();
558        }
559
560        public void refreshRow() throws SQLException {
561                rs.refreshRow();
562        }
563
564        public void cancelRowUpdates() throws SQLException {
565                rs.cancelRowUpdates();
566        }
567
568        public void moveToInsertRow() throws SQLException {
569                rs.moveToInsertRow();
570        }
571
572        public void moveToCurrentRow() throws SQLException {
573                rs.moveToCurrentRow();
574        }
575
576        public Statement getStatement() throws SQLException {
577                return rs.getStatement();
578        }
579
580        public Object getObject(int columnIndex, Map<String, Class<?>> map) throws SQLException {
581                return rs.getObject(columnIndex, map);
582        }
583
584        public Ref getRef(int columnIndex) throws SQLException {
585                return rs.getRef(columnIndex);
586        }
587
588        public Blob getBlob(int columnIndex) throws SQLException {
589                return rs.getBlob(columnIndex);
590        }
591
592        public Clob getClob(int columnIndex) throws SQLException {
593                return rs.getClob(columnIndex);
594        }
595
596        public Array getArray(int columnIndex) throws SQLException {
597                return rs.getArray(columnIndex);
598        }
599
600        public Object getObject(String columnLabel, Map<String, Class<?>> map) throws SQLException {
601                return rs.getObject(columnLabel, map);
602        }
603
604        public Ref getRef(String columnLabel) throws SQLException {
605                return rs.getRef(columnLabel);
606        }
607
608        public Blob getBlob(String columnLabel) throws SQLException {
609                return rs.getBlob(columnLabel);
610        }
611
612        public Clob getClob(String columnLabel) throws SQLException {
613                return rs.getClob(columnLabel);
614        }
615
616        public Array getArray(String columnLabel) throws SQLException {
617                return rs.getArray(columnLabel);
618        }
619
620        public Date getDate(int columnIndex, Calendar cal) throws SQLException {
621                return rs.getDate(columnIndex, cal);
622        }
623
624        public Date getDate(String columnLabel, Calendar cal) throws SQLException {
625                return rs.getDate(columnLabel, cal);
626        }
627
628        public Time getTime(int columnIndex, Calendar cal) throws SQLException {
629                return rs.getTime(columnIndex, cal);
630        }
631
632        public Time getTime(String columnLabel, Calendar cal) throws SQLException {
633                return rs.getTime(columnLabel, cal);
634        }
635
636        public Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException {
637                return rs.getTimestamp(columnIndex, cal);
638        }
639
640        public Timestamp getTimestamp(String columnLabel, Calendar cal) throws SQLException {
641                return rs.getTimestamp(columnLabel, cal);
642        }
643
644        public URL getURL(int columnIndex) throws SQLException {
645                return rs.getURL(columnIndex);
646        }
647
648        public URL getURL(String columnLabel) throws SQLException {
649                return rs.getURL(columnLabel);
650        }
651
652        public void updateRef(int columnIndex, Ref x) throws SQLException {
653                rs.updateRef(columnIndex, x);
654        }
655
656        public void updateRef(String columnLabel, Ref x) throws SQLException {
657                rs.updateRef(columnLabel, x);
658        }
659
660        public void updateBlob(int columnIndex, Blob x) throws SQLException {
661                rs.updateBlob(columnIndex, x);
662        }
663
664        public void updateBlob(String columnLabel, Blob x) throws SQLException {
665                rs.updateBlob(columnLabel, x);
666        }
667
668        public void updateClob(int columnIndex, Clob x) throws SQLException {
669                rs.updateClob(columnIndex, x);
670        }
671
672        public void updateClob(String columnLabel, Clob x) throws SQLException {
673                rs.updateClob(columnLabel, x);
674        }
675
676        public void updateArray(int columnIndex, Array x) throws SQLException {
677                rs.updateArray(columnIndex, x);
678        }
679
680        public void updateArray(String columnLabel, Array x) throws SQLException {
681                rs.updateArray(columnLabel, x);
682        }
683
684        public RowId getRowId(int columnIndex) throws SQLException {
685                return rs.getRowId(columnIndex);
686        }
687
688        public RowId getRowId(String columnLabel) throws SQLException {
689                return rs.getRowId(columnLabel);
690        }
691
692        public void updateRowId(int columnIndex, RowId x) throws SQLException {
693                rs.updateRowId(columnIndex, x);
694        }
695
696        public void updateRowId(String columnLabel, RowId x) throws SQLException {
697                rs.updateRowId(columnLabel, x);
698        }
699
700        public int getHoldability() throws SQLException {
701                return rs.getHoldability();
702        }
703
704        public boolean isClosed() throws SQLException {
705                return rs.isClosed();
706        }
707
708        public void updateNString(int columnIndex, String nString) throws SQLException {
709                rs.updateNString(columnIndex, nString);
710        }
711
712        public void updateNString(String columnLabel, String nString) throws SQLException {
713                rs.updateNString(columnLabel, nString);
714        }
715
716        public void updateNClob(int columnIndex, NClob nClob) throws SQLException {
717                rs.updateNClob(columnIndex, nClob);
718        }
719
720        public void updateNClob(String columnLabel, NClob nClob) throws SQLException {
721                rs.updateNClob(columnLabel, nClob);
722        }
723
724        public NClob getNClob(int columnIndex) throws SQLException {
725                return rs.getNClob(columnIndex);
726        }
727
728        public NClob getNClob(String columnLabel) throws SQLException {
729                return rs.getNClob(columnLabel);
730        }
731
732        public SQLXML getSQLXML(int columnIndex) throws SQLException {
733                return rs.getSQLXML(columnIndex);
734        }
735
736        public SQLXML getSQLXML(String columnLabel) throws SQLException {
737                return rs.getSQLXML(columnLabel);
738        }
739
740        public void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException {
741                rs.updateSQLXML(columnIndex, xmlObject);
742        }
743
744        public void updateSQLXML(String columnLabel, SQLXML xmlObject) throws SQLException {
745                rs.updateSQLXML(columnLabel, xmlObject);
746        }
747
748        public String getNString(int columnIndex) throws SQLException {
749                return rs.getNString(columnIndex);
750        }
751
752        public String getNString(String columnLabel) throws SQLException {
753                return rs.getNString(columnLabel);
754        }
755
756        public Reader getNCharacterStream(int columnIndex) throws SQLException {
757                return rs.getNCharacterStream(columnIndex);
758        }
759
760        public Reader getNCharacterStream(String columnLabel) throws SQLException {
761                return rs.getNCharacterStream(columnLabel);
762        }
763
764        public void updateNCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
765                rs.updateNCharacterStream(columnIndex, x, length);
766        }
767
768        public void updateNCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
769                rs.updateNCharacterStream(columnLabel, reader, length);
770        }
771
772        public void updateAsciiStream(int columnIndex, InputStream x, long length) throws SQLException {
773                rs.updateAsciiStream(columnIndex, x, length);
774        }
775
776        public void updateBinaryStream(int columnIndex, InputStream x, long length) throws SQLException {
777                rs.updateBinaryStream(columnIndex, x, length);
778        }
779
780        public void updateCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
781                rs.updateCharacterStream(columnIndex, x, length);
782        }
783
784        public void updateAsciiStream(String columnLabel, InputStream x, long length) throws SQLException {
785                rs.updateAsciiStream(columnLabel, x, length);
786        }
787
788        public void updateBinaryStream(String columnLabel, InputStream x, long length) throws SQLException {
789                rs.updateBinaryStream(columnLabel, x, length);
790        }
791
792        public void updateCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
793                rs.updateCharacterStream(columnLabel, reader, length);
794        }
795
796        public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException {
797                rs.updateBlob(columnIndex, inputStream, length);
798        }
799
800        public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException {
801                rs.updateBlob(columnLabel, inputStream, length);
802        }
803
804        public void updateClob(int columnIndex, Reader reader, long length) throws SQLException {
805                rs.updateClob(columnIndex, reader, length);
806        }
807
808        public void updateClob(String columnLabel, Reader reader, long length) throws SQLException {
809                rs.updateClob(columnLabel, reader, length);
810        }
811
812        public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException {
813                rs.updateNClob(columnIndex, reader, length);
814        }
815
816        public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException {
817                rs.updateNClob(columnLabel, reader, length);
818        }
819
820        public void updateNCharacterStream(int columnIndex, Reader x) throws SQLException {
821                rs.updateNCharacterStream(columnIndex, x);
822        }
823
824        public void updateNCharacterStream(String columnLabel, Reader reader) throws SQLException {
825                rs.updateNCharacterStream(columnLabel, reader);
826        }
827
828        public void updateAsciiStream(int columnIndex, InputStream x) throws SQLException {
829                rs.updateAsciiStream(columnIndex, x);
830        }
831
832        public void updateBinaryStream(int columnIndex, InputStream x) throws SQLException {
833                rs.updateBinaryStream(columnIndex, x);
834        }
835
836        public void updateCharacterStream(int columnIndex, Reader x) throws SQLException {
837                rs.updateCharacterStream(columnIndex, x);
838        }
839
840        public void updateAsciiStream(String columnLabel, InputStream x) throws SQLException {
841                rs.updateAsciiStream(columnLabel, x);
842        }
843
844        public void updateBinaryStream(String columnLabel, InputStream x) throws SQLException {
845                rs.updateBinaryStream(columnLabel, x);
846        }
847
848        public void updateCharacterStream(String columnLabel, Reader reader) throws SQLException {
849                rs.updateCharacterStream(columnLabel, reader);
850        }
851
852        public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException {
853                rs.updateBlob(columnIndex, inputStream);
854        }
855
856        public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException {
857                rs.updateBlob(columnLabel, inputStream);
858        }
859
860        public void updateClob(int columnIndex, Reader reader) throws SQLException {
861                rs.updateClob(columnIndex, reader);
862        }
863
864        public void updateClob(String columnLabel, Reader reader) throws SQLException {
865                rs.updateClob(columnLabel, reader);
866        }
867
868        public void updateNClob(int columnIndex, Reader reader) throws SQLException {
869                rs.updateNClob(columnIndex, reader);
870        }
871
872        public void updateNClob(String columnLabel, Reader reader) throws SQLException {
873                rs.updateNClob(columnLabel, reader);
874        }
875
876        public <T> T getObject(int columnIndex, Class<T> type) throws SQLException {
877                return rs.getObject(columnIndex, type);
878        }
879
880        public <T> T getObject(String columnLabel, Class<T> type) throws SQLException {
881                return rs.getObject(columnLabel, type);
882        }
883
884        public void updateObject(int columnIndex, Object x, SQLType targetSqlType, int scaleOrLength) throws SQLException {
885                rs.updateObject(columnIndex, x, targetSqlType, scaleOrLength);
886        }
887
888        public void updateObject(String columnLabel, Object x, SQLType targetSqlType, int scaleOrLength)
889                        throws SQLException {
890                rs.updateObject(columnLabel, x, targetSqlType, scaleOrLength);
891        }
892
893        public void updateObject(int columnIndex, Object x, SQLType targetSqlType) throws SQLException {
894                rs.updateObject(columnIndex, x, targetSqlType);
895        }
896
897        public void updateObject(String columnLabel, Object x, SQLType targetSqlType) throws SQLException {
898                rs.updateObject(columnLabel, x, targetSqlType);
899        }
900        
901        
902}