Source code

001/*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements.  See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License.  You may obtain a copy of the License at
008 *
009 *      http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017package org.apache.commons.dbutils;
018
019import java.io.InputStream;
020import java.io.Reader;
021import java.math.BigDecimal;
022import java.net.URL;
023import java.sql.Array;
024import java.sql.Blob;
025import java.sql.Clob;
026import java.sql.Date;
027import java.sql.NClob;
028import java.sql.Ref;
029import java.sql.ResultSet;
030import java.sql.ResultSetMetaData;
031import java.sql.RowId;
032import java.sql.SQLException;
033import java.sql.SQLWarning;
034import java.sql.SQLXML;
035import java.sql.Statement;
036import java.sql.Time;
037import java.sql.Timestamp;
038import java.util.Calendar;
039import java.util.Map;
040
041/**
042 * Extensions of this class convert ResultSets into other objects.
043 *
044 * According to the <i>DRY</i> principle (Don't Repeat Yourself), repeating {@code resultSet}
045 * variable inside the {@link ResultSetHandler#handle(ResultSet)} over and over for each iteration
046 * can get a little tedious, {@code AbstractResultSetHandler} implicitly gives users access to
047 * {@code ResultSet}'s methods.
048 *
049 * <b>NOTE</b> This class is <i>NOT</i> thread safe!
050 *
051 * @param <T> the target type the input ResultSet will be converted to.
052 * @since 1.6
053 */
054public abstract class BaseResultSetHandler<T> implements ResultSetHandler<T> {
055
056    /**
057     * The adapted ResultSet.
058     */
059    private ResultSet rs;
060
061    /**
062     * {@inheritDoc}
063     */
064    @Override
065    public final T handle(final ResultSet rs) throws SQLException {
066        if (this.rs != null) {
067            throw new IllegalStateException("Re-entry not allowed!");
068        }
069
070        this.rs = rs;
071
072        try {
073            return handle();
074        } finally {
075            this.rs = null;
076        }
077    }
078
079    /**
080     * Turn the {@code ResultSet} into an Object.
081     *
082     * @return An Object initialized with {@code ResultSet} data
083     * @throws SQLException if a database access error occurs
084     * @see ResultSetHandler#handle(ResultSet)
085     */
086    protected abstract T handle() throws SQLException;
087
088    /**
089     * @param row
090     * @return
091     * @throws SQLException
092     * @see java.sql.ResultSet#absolute(int)
093     */
094    protected final boolean absolute(final int row) throws SQLException {
095        return rs.absolute(row);
096    }
097
098    /**
099     * @throws SQLException
100     * @see java.sql.ResultSet#afterLast()
101     */
102    protected final void afterLast() throws SQLException {
103        rs.afterLast();
104    }
105
106    /**
107     * @throws SQLException
108     * @see java.sql.ResultSet#beforeFirst()
109     */
110    protected final void beforeFirst() throws SQLException {
111        rs.beforeFirst();
112    }
113
114    /**
115     * @throws SQLException
116     * @see java.sql.ResultSet#cancelRowUpdates()
117     */
118    protected final void cancelRowUpdates() throws SQLException {
119        rs.cancelRowUpdates();
120    }
121
122    /**
123     * @throws SQLException
124     * @see java.sql.ResultSet#clearWarnings()
125     */
126    protected final void clearWarnings() throws SQLException {
127        rs.clearWarnings();
128    }
129
130    /**
131     * @throws SQLException
132     * @see java.sql.ResultSet#close()
133     */
134    protected final void close() throws SQLException {
135        rs.close();
136    }
137
138    /**
139     * @throws SQLException
140     * @see java.sql.ResultSet#deleteRow()
141     */
142    protected final void deleteRow() throws SQLException {
143        rs.deleteRow();
144    }
145
146    /**
147     * @param columnLabel
148     * @return
149     * @throws SQLException
150     * @see java.sql.ResultSet#findColumn(java.lang.String)
151     */
152    protected final int findColumn(final String columnLabel) throws SQLException {
153        return rs.findColumn(columnLabel);
154    }
155
156    /**
157     * @return
158     * @throws SQLException
159     * @see java.sql.ResultSet#first()
160     */
161    protected final boolean first() throws SQLException {
162        return rs.first();
163    }
164
165    /**
166     * @param columnIndex
167     * @return
168     * @throws SQLException
169     * @see java.sql.ResultSet#getArray(int)
170     */
171    protected final Array getArray(final int columnIndex) throws SQLException {
172        return rs.getArray(columnIndex);
173    }
174
175    /**
176     * @param columnLabel
177     * @return
178     * @throws SQLException
179     * @see java.sql.ResultSet#getArray(java.lang.String)
180     */
181    protected final Array getArray(final String columnLabel) throws SQLException {
182        return rs.getArray(columnLabel);
183    }
184
185    /**
186     * @param columnIndex
187     * @return
188     * @throws SQLException
189     * @see java.sql.ResultSet#getAsciiStream(int)
190     */
191    protected final InputStream getAsciiStream(final int columnIndex) throws SQLException {
192        return rs.getAsciiStream(columnIndex);
193    }
194
195    /**
196     * @param columnLabel
197     * @return
198     * @throws SQLException
199     * @see java.sql.ResultSet#getAsciiStream(java.lang.String)
200     */
201    protected final InputStream getAsciiStream(final String columnLabel) throws SQLException {
202        return rs.getAsciiStream(columnLabel);
203    }
204
205    /**
206     * @param columnIndex
207     * @param scale
208     * @return
209     * @throws SQLException
210     * @deprecated
211     * @see java.sql.ResultSet#getBigDecimal(int, int)
212     */
213    @Deprecated
214    protected final BigDecimal getBigDecimal(final int columnIndex, final int scale) throws SQLException {
215        return rs.getBigDecimal(columnIndex, scale);
216    }
217
218    /**
219     * @param columnIndex
220     * @return
221     * @throws SQLException
222     * @see java.sql.ResultSet#getBigDecimal(int)
223     */
224    protected final BigDecimal getBigDecimal(final int columnIndex) throws SQLException {
225        return rs.getBigDecimal(columnIndex);
226    }
227
228    /**
229     * @param columnLabel
230     * @param scale
231     * @return
232     * @throws SQLException
233     * @deprecated
234     * @see java.sql.ResultSet#getBigDecimal(java.lang.String, int)
235     */
236    @Deprecated
237    protected final BigDecimal getBigDecimal(final String columnLabel, final int scale) throws SQLException {
238        return rs.getBigDecimal(columnLabel, scale);
239    }
240
241    /**
242     * @param columnLabel
243     * @return
244     * @throws SQLException
245     * @see java.sql.ResultSet#getBigDecimal(java.lang.String)
246     */
247    protected final BigDecimal getBigDecimal(final String columnLabel) throws SQLException {
248        return rs.getBigDecimal(columnLabel);
249    }
250
251    /**
252     * @param columnIndex
253     * @return
254     * @throws SQLException
255     * @see java.sql.ResultSet#getBinaryStream(int)
256     */
257    protected final InputStream getBinaryStream(final int columnIndex) throws SQLException {
258        return rs.getBinaryStream(columnIndex);
259    }
260
261    /**
262     * @param columnLabel
263     * @return
264     * @throws SQLException
265     * @see java.sql.ResultSet#getBinaryStream(java.lang.String)
266     */
267    protected final InputStream getBinaryStream(final String columnLabel) throws SQLException {
268        return rs.getBinaryStream(columnLabel);
269    }
270
271    /**
272     * @param columnIndex
273     * @return
274     * @throws SQLException
275     * @see java.sql.ResultSet#getBlob(int)
276     */
277    protected final Blob getBlob(final int columnIndex) throws SQLException {
278        return rs.getBlob(columnIndex);
279    }
280
281    /**
282     * @param columnLabel
283     * @return
284     * @throws SQLException
285     * @see java.sql.ResultSet#getBlob(java.lang.String)
286     */
287    protected final Blob getBlob(final String columnLabel) throws SQLException {
288        return rs.getBlob(columnLabel);
289    }
290
291    /**
292     * @param columnIndex
293     * @return
294     * @throws SQLException
295     * @see java.sql.ResultSet#getBoolean(int)
296     */
297    protected final boolean getBoolean(final int columnIndex) throws SQLException {
298        return rs.getBoolean(columnIndex);
299    }
300
301    /**
302     * @param columnLabel
303     * @return
304     * @throws SQLException
305     * @see java.sql.ResultSet#getBoolean(java.lang.String)
306     */
307    protected final boolean getBoolean(final String columnLabel) throws SQLException {
308        return rs.getBoolean(columnLabel);
309    }
310
311    /**
312     * @param columnIndex
313     * @return
314     * @throws SQLException
315     * @see java.sql.ResultSet#getByte(int)
316     */
317    protected final byte getByte(final int columnIndex) throws SQLException {
318        return rs.getByte(columnIndex);
319    }
320
321    /**
322     * @param columnLabel
323     * @return
324     * @throws SQLException
325     * @see java.sql.ResultSet#getByte(java.lang.String)
326     */
327    protected final byte getByte(final String columnLabel) throws SQLException {
328        return rs.getByte(columnLabel);
329    }
330
331    /**
332     * @param columnIndex
333     * @return
334     * @throws SQLException
335     * @see java.sql.ResultSet#getBytes(int)
336     */
337    protected final byte[] getBytes(final int columnIndex) throws SQLException {
338        return rs.getBytes(columnIndex);
339    }
340
341    /**
342     * @param columnLabel
343     * @return
344     * @throws SQLException
345     * @see java.sql.ResultSet#getBytes(java.lang.String)
346     */
347    protected final byte[] getBytes(final String columnLabel) throws SQLException {
348        return rs.getBytes(columnLabel);
349    }
350
351    /**
352     * @param columnIndex
353     * @return
354     * @throws SQLException
355     * @see java.sql.ResultSet#getCharacterStream(int)
356     */
357    protected final Reader getCharacterStream(final int columnIndex) throws SQLException {
358        return rs.getCharacterStream(columnIndex);
359    }
360
361    /**
362     * @param columnLabel
363     * @return
364     * @throws SQLException
365     * @see java.sql.ResultSet#getCharacterStream(java.lang.String)
366     */
367    protected final Reader getCharacterStream(final String columnLabel) throws SQLException {
368        return rs.getCharacterStream(columnLabel);
369    }
370
371    /**
372     * @param columnIndex
373     * @return
374     * @throws SQLException
375     * @see java.sql.ResultSet#getClob(int)
376     */
377    protected final Clob getClob(final int columnIndex) throws SQLException {
378        return rs.getClob(columnIndex);
379    }
380
381    /**
382     * @param columnLabel
383     * @return
384     * @throws SQLException
385     * @see java.sql.ResultSet#getClob(java.lang.String)
386     */
387    protected final Clob getClob(final String columnLabel) throws SQLException {
388        return rs.getClob(columnLabel);
389    }
390
391    /**
392     * @return
393     * @throws SQLException
394     * @see java.sql.ResultSet#getConcurrency()
395     */
396    protected final int getConcurrency() throws SQLException {
397        return rs.getConcurrency();
398    }
399
400    /**
401     * @return
402     * @throws SQLException
403     * @see java.sql.ResultSet#getCursorName()
404     */
405    protected final String getCursorName() throws SQLException {
406        return rs.getCursorName();
407    }
408
409    /**
410     * @param columnIndex
411     * @param cal
412     * @return
413     * @throws SQLException
414     * @see java.sql.ResultSet#getDate(int, java.util.Calendar)
415     */
416    protected final Date getDate(final int columnIndex, final Calendar cal) throws SQLException {
417        return rs.getDate(columnIndex, cal);
418    }
419
420    /**
421     * @param columnIndex
422     * @return
423     * @throws SQLException
424     * @see java.sql.ResultSet#getDate(int)
425     */
426    protected final Date getDate(final int columnIndex) throws SQLException {
427        return rs.getDate(columnIndex);
428    }
429
430    /**
431     * @param columnLabel
432     * @param cal
433     * @return
434     * @throws SQLException
435     * @see java.sql.ResultSet#getDate(java.lang.String, java.util.Calendar)
436     */
437    protected final Date getDate(final String columnLabel, final Calendar cal) throws SQLException {
438        return rs.getDate(columnLabel, cal);
439    }
440
441    /**
442     * @param columnLabel
443     * @return
444     * @throws SQLException
445     * @see java.sql.ResultSet#getDate(java.lang.String)
446     */
447    protected final Date getDate(final String columnLabel) throws SQLException {
448        return rs.getDate(columnLabel);
449    }
450
451    /**
452     * @param columnIndex
453     * @return
454     * @throws SQLException
455     * @see java.sql.ResultSet#getDouble(int)
456     */
457    protected final double getDouble(final int columnIndex) throws SQLException {
458        return rs.getDouble(columnIndex);
459    }
460
461    /**
462     * @param columnLabel
463     * @return
464     * @throws SQLException
465     * @see java.sql.ResultSet#getDouble(java.lang.String)
466     */
467    protected final double getDouble(final String columnLabel) throws SQLException {
468        return rs.getDouble(columnLabel);
469    }
470
471    /**
472     * @return
473     * @throws SQLException
474     * @see java.sql.ResultSet#getFetchDirection()
475     */
476    protected final int getFetchDirection() throws SQLException {
477        return rs.getFetchDirection();
478    }
479
480    /**
481     * @return
482     * @throws SQLException
483     * @see java.sql.ResultSet#getFetchSize()
484     */
485    protected final int getFetchSize() throws SQLException {
486        return rs.getFetchSize();
487    }
488
489    /**
490     * @param columnIndex
491     * @return
492     * @throws SQLException
493     * @see java.sql.ResultSet#getFloat(int)
494     */
495    protected final float getFloat(final int columnIndex) throws SQLException {
496        return rs.getFloat(columnIndex);
497    }
498
499    /**
500     * @param columnLabel
501     * @return
502     * @throws SQLException
503     * @see java.sql.ResultSet#getFloat(java.lang.String)
504     */
505    protected final float getFloat(final String columnLabel) throws SQLException {
506        return rs.getFloat(columnLabel);
507    }
508
509    /**
510     * @return
511     * @throws SQLException
512     * @see java.sql.ResultSet#getHoldability()
513     */
514    protected final int getHoldability() throws SQLException {
515        return rs.getHoldability();
516    }
517
518    /**
519     * @param columnIndex
520     * @return
521     * @throws SQLException
522     * @see java.sql.ResultSet#getInt(int)
523     */
524    protected final int getInt(final int columnIndex) throws SQLException {
525        return rs.getInt(columnIndex);
526    }
527
528    /**
529     * @param columnLabel
530     * @return
531     * @throws SQLException
532     * @see java.sql.ResultSet#getInt(java.lang.String)
533     */
534    protected final int getInt(final String columnLabel) throws SQLException {
535        return rs.getInt(columnLabel);
536    }
537
538    /**
539     * @param columnIndex
540     * @return
541     * @throws SQLException
542     * @see java.sql.ResultSet#getLong(int)
543     */
544    protected final long getLong(final int columnIndex) throws SQLException {
545        return rs.getLong(columnIndex);
546    }
547
548    /**
549     * @param columnLabel
550     * @return
551     * @throws SQLException
552     * @see java.sql.ResultSet#getLong(java.lang.String)
553     */
554    protected final long getLong(final String columnLabel) throws SQLException {
555        return rs.getLong(columnLabel);
556    }
557
558    /**
559     * @return
560     * @throws SQLException
561     * @see java.sql.ResultSet#getMetaData()
562     */
563    protected final ResultSetMetaData getMetaData() throws SQLException {
564        return rs.getMetaData();
565    }
566
567    /**
568     * @param columnIndex
569     * @return
570     * @throws SQLException
571     * @see java.sql.ResultSet#getNCharacterStream(int)
572     */
573    protected final Reader getNCharacterStream(final int columnIndex) throws SQLException {
574        return rs.getNCharacterStream(columnIndex);
575    }
576
577    /**
578     * @param columnLabel
579     * @return
580     * @throws SQLException
581     * @see java.sql.ResultSet#getNCharacterStream(java.lang.String)
582     */
583    protected final Reader getNCharacterStream(final String columnLabel) throws SQLException {
584        return rs.getNCharacterStream(columnLabel);
585    }
586
587    /**
588     * @param columnIndex
589     * @return
590     * @throws SQLException
591     * @see java.sql.ResultSet#getNClob(int)
592     */
593    protected final NClob getNClob(final int columnIndex) throws SQLException {
594        return rs.getNClob(columnIndex);
595    }
596
597    /**
598     * @param columnLabel
599     * @return
600     * @throws SQLException
601     * @see java.sql.ResultSet#getNClob(java.lang.String)
602     */
603    protected final NClob getNClob(final String columnLabel) throws SQLException {
604        return rs.getNClob(columnLabel);
605    }
606
607    /**
608     * @param columnIndex
609     * @return
610     * @throws SQLException
611     * @see java.sql.ResultSet#getNString(int)
612     */
613    protected final String getNString(final int columnIndex) throws SQLException {
614        return rs.getNString(columnIndex);
615    }
616
617    /**
618     * @param columnLabel
619     * @return
620     * @throws SQLException
621     * @see java.sql.ResultSet#getNString(java.lang.String)
622     */
623    protected final String getNString(final String columnLabel) throws SQLException {
624        return rs.getNString(columnLabel);
625    }
626
627    /**
628     * @param columnIndex
629     * @param map
630     * @return
631     * @throws SQLException
632     * @see java.sql.ResultSet#getObject(int, java.util.Map)
633     */
634    protected final Object getObject(final int columnIndex, final Map<String, Class<?>> map) throws SQLException {
635        return rs.getObject(columnIndex, map);
636    }
637
638    /**
639     * @param columnIndex
640     * @return
641     * @throws SQLException
642     * @see java.sql.ResultSet#getObject(int)
643     */
644    protected final Object getObject(final int columnIndex) throws SQLException {
645        return rs.getObject(columnIndex);
646    }
647
648    /**
649     * @param columnLabel
650     * @param map
651     * @return
652     * @throws SQLException
653     * @see java.sql.ResultSet#getObject(java.lang.String, java.util.Map)
654     */
655    protected final Object getObject(final String columnLabel, final Map<String, Class<?>> map) throws SQLException {
656        return rs.getObject(columnLabel, map);
657    }
658
659    /**
660     * @param columnLabel
661     * @return
662     * @throws SQLException
663     * @see java.sql.ResultSet#getObject(java.lang.String)
664     */
665    protected final Object getObject(final String columnLabel) throws SQLException {
666        return rs.getObject(columnLabel);
667    }
668
669    /**
670     * @param columnIndex
671     * @return
672     * @throws SQLException
673     * @see java.sql.ResultSet#getRef(int)
674     */
675    protected final Ref getRef(final int columnIndex) throws SQLException {
676        return rs.getRef(columnIndex);
677    }
678
679    /**
680     * @param columnLabel
681     * @return
682     * @throws SQLException
683     * @see java.sql.ResultSet#getRef(java.lang.String)
684     */
685    protected final Ref getRef(final String columnLabel) throws SQLException {
686        return rs.getRef(columnLabel);
687    }
688
689    /**
690     * @return
691     * @throws SQLException
692     * @see java.sql.ResultSet#getRow()
693     */
694    protected final int getRow() throws SQLException {
695        return rs.getRow();
696    }
697
698    /**
699     * @param columnIndex
700     * @return
701     * @throws SQLException
702     * @see java.sql.ResultSet#getRowId(int)
703     */
704    protected final RowId getRowId(final int columnIndex) throws SQLException {
705        return rs.getRowId(columnIndex);
706    }
707
708    /**
709     * @param columnLabel
710     * @return
711     * @throws SQLException
712     * @see java.sql.ResultSet#getRowId(java.lang.String)
713     */
714    protected final RowId getRowId(final String columnLabel) throws SQLException {
715        return rs.getRowId(columnLabel);
716    }
717
718    /**
719     * @param columnIndex
720     * @return
721     * @throws SQLException
722     * @see java.sql.ResultSet#getSQLXML(int)
723     */
724    protected final SQLXML getSQLXML(final int columnIndex) throws SQLException {
725        return rs.getSQLXML(columnIndex);
726    }
727
728    /**
729     * @param columnLabel
730     * @return
731     * @throws SQLException
732     * @see java.sql.ResultSet#getSQLXML(java.lang.String)
733     */
734    protected final SQLXML getSQLXML(final String columnLabel) throws SQLException {
735        return rs.getSQLXML(columnLabel);
736    }
737
738    /**
739     * @param columnIndex
740     * @return
741     * @throws SQLException
742     * @see java.sql.ResultSet#getShort(int)
743     */
744    protected final short getShort(final int columnIndex) throws SQLException {
745        return rs.getShort(columnIndex);
746    }
747
748    /**
749     * @param columnLabel
750     * @return
751     * @throws SQLException
752     * @see java.sql.ResultSet#getShort(java.lang.String)
753     */
754    protected final short getShort(final String columnLabel) throws SQLException {
755        return rs.getShort(columnLabel);
756    }
757
758    /**
759     * @return
760     * @throws SQLException
761     * @see java.sql.ResultSet#getStatement()
762     */
763    protected final Statement getStatement() throws SQLException {
764        return rs.getStatement();
765    }
766
767    /**
768     * @param columnIndex
769     * @return
770     * @throws SQLException
771     * @see java.sql.ResultSet#getString(int)
772     */
773    protected final String getString(final int columnIndex) throws SQLException {
774        return rs.getString(columnIndex);
775    }
776
777    /**
778     * @param columnLabel
779     * @return
780     * @throws SQLException
781     * @see java.sql.ResultSet#getString(java.lang.String)
782     */
783    protected final String getString(final String columnLabel) throws SQLException {
784        return rs.getString(columnLabel);
785    }
786
787    /**
788     * @param columnIndex
789     * @param cal
790     * @return
791     * @throws SQLException
792     * @see java.sql.ResultSet#getTime(int, java.util.Calendar)
793     */
794    protected final Time getTime(final int columnIndex, final Calendar cal) throws SQLException {
795        return rs.getTime(columnIndex, cal);
796    }
797
798    /**
799     * @param columnIndex
800     * @return
801     * @throws SQLException
802     * @see java.sql.ResultSet#getTime(int)
803     */
804    protected final Time getTime(final int columnIndex) throws SQLException {
805        return rs.getTime(columnIndex);
806    }
807
808    /**
809     * @param columnLabel
810     * @param cal
811     * @return
812     * @throws SQLException
813     * @see java.sql.ResultSet#getTime(java.lang.String, java.util.Calendar)
814     */
815    protected final Time getTime(final String columnLabel, final Calendar cal) throws SQLException {
816        return rs.getTime(columnLabel, cal);
817    }
818
819    /**
820     * @param columnLabel
821     * @return
822     * @throws SQLException
823     * @see java.sql.ResultSet#getTime(java.lang.String)
824     */
825    protected final Time getTime(final String columnLabel) throws SQLException {
826        return rs.getTime(columnLabel);
827    }
828
829    /**
830     * @param columnIndex
831     * @param cal
832     * @return
833     * @throws SQLException
834     * @see java.sql.ResultSet#getTimestamp(int, java.util.Calendar)
835     */
836    protected final Timestamp getTimestamp(final int columnIndex, final Calendar cal) throws SQLException {
837        return rs.getTimestamp(columnIndex, cal);
838    }
839
840    /**
841     * @param columnIndex
842     * @return
843     * @throws SQLException
844     * @see java.sql.ResultSet#getTimestamp(int)
845     */
846    protected final Timestamp getTimestamp(final int columnIndex) throws SQLException {
847        return rs.getTimestamp(columnIndex);
848    }
849
850    /**
851     * @param columnLabel
852     * @param cal
853     * @return
854     * @throws SQLException
855     * @see java.sql.ResultSet#getTimestamp(java.lang.String, java.util.Calendar)
856     */
857    protected final Timestamp getTimestamp(final String columnLabel, final Calendar cal) throws SQLException {
858        return rs.getTimestamp(columnLabel, cal);
859    }
860
861    /**
862     * @param columnLabel
863     * @return
864     * @throws SQLException
865     * @see java.sql.ResultSet#getTimestamp(java.lang.String)
866     */
867    protected final Timestamp getTimestamp(final String columnLabel) throws SQLException {
868        return rs.getTimestamp(columnLabel);
869    }
870
871    /**
872     * @return
873     * @throws SQLException
874     * @see java.sql.ResultSet#getType()
875     */
876    protected final int getType() throws SQLException {
877        return rs.getType();
878    }
879
880    /**
881     * @param columnIndex
882     * @return
883     * @throws SQLException
884     * @see java.sql.ResultSet#getURL(int)
885     */
886    protected final URL getURL(final int columnIndex) throws SQLException {
887        return rs.getURL(columnIndex);
888    }
889
890    /**
891     * @param columnLabel
892     * @return
893     * @throws SQLException
894     * @see java.sql.ResultSet#getURL(java.lang.String)
895     */
896    protected final URL getURL(final String columnLabel) throws SQLException {
897        return rs.getURL(columnLabel);
898    }
899
900    /**
901     * @param columnIndex
902     * @return
903     * @throws SQLException
904     * @deprecated
905     * @see java.sql.ResultSet#getUnicodeStream(int)
906     */
907    @Deprecated
908    protected final InputStream getUnicodeStream(final int columnIndex) throws SQLException {
909        return rs.getUnicodeStream(columnIndex);
910    }
911
912    /**
913     * @param columnLabel
914     * @return
915     * @throws SQLException
916     * @deprecated
917     * @see java.sql.ResultSet#getUnicodeStream(java.lang.String)
918     */
919    @Deprecated
920    protected final InputStream getUnicodeStream(final String columnLabel) throws SQLException {
921        return rs.getUnicodeStream(columnLabel);
922    }
923
924    /**
925     * @return
926     * @throws SQLException
927     * @see java.sql.ResultSet#getWarnings()
928     */
929    protected final SQLWarning getWarnings() throws SQLException {
930        return rs.getWarnings();
931    }
932
933    /**
934     * @throws SQLException
935     * @see java.sql.ResultSet#insertRow()
936     */
937    protected final void insertRow() throws SQLException {
938        rs.insertRow();
939    }
940
941    /**
942     * @return
943     * @throws SQLException
944     * @see java.sql.ResultSet#isAfterLast()
945     */
946    protected final boolean isAfterLast() throws SQLException {
947        return rs.isAfterLast();
948    }
949
950    /**
951     * @return
952     * @throws SQLException
953     * @see java.sql.ResultSet#isBeforeFirst()
954     */
955    protected final boolean isBeforeFirst() throws SQLException {
956        return rs.isBeforeFirst();
957    }
958
959    /**
960     * @return
961     * @throws SQLException
962     * @see java.sql.ResultSet#isClosed()
963     */
964    protected final boolean isClosed() throws SQLException {
965        return rs.isClosed();
966    }
967
968    /**
969     * @return
970     * @throws SQLException
971     * @see java.sql.ResultSet#isFirst()
972     */
973    protected final boolean isFirst() throws SQLException {
974        return rs.isFirst();
975    }
976
977    /**
978     * @return
979     * @throws SQLException
980     * @see java.sql.ResultSet#isLast()
981     */
982    protected final boolean isLast() throws SQLException {
983        return rs.isLast();
984    }
985
986    /**
987     * @param iface
988     * @return
989     * @throws SQLException
990     * @see java.sql.Wrapper#isWrapperFor(java.lang.Class)
991     */
992    protected final boolean isWrapperFor(final Class<?> iface) throws SQLException {
993        return rs.isWrapperFor(iface);
994    }
995
996    /**
997     * @return
998     * @throws SQLException
999     * @see java.sql.ResultSet#last()
1000     */
1001    protected final boolean last() throws SQLException {
1002        return rs.last();
1003    }
1004
1005    /**
1006     * @throws SQLException
1007     * @see java.sql.ResultSet#moveToCurrentRow()
1008     */
1009    protected final void moveToCurrentRow() throws SQLException {
1010        rs.moveToCurrentRow();
1011    }
1012
1013    /**
1014     * @throws SQLException
1015     * @see java.sql.ResultSet#moveToInsertRow()
1016     */
1017    protected final void moveToInsertRow() throws SQLException {
1018        rs.moveToInsertRow();
1019    }
1020
1021    /**
1022     * @return
1023     * @throws SQLException
1024     * @see java.sql.ResultSet#next()
1025     */
1026    protected final boolean next() throws SQLException {
1027        return rs.next();
1028    }
1029
1030    /**
1031     * @return
1032     * @throws SQLException
1033     * @see java.sql.ResultSet#previous()
1034     */
1035    protected final boolean previous() throws SQLException {
1036        return rs.previous();
1037    }
1038
1039    /**
1040     * @throws SQLException
1041     * @see java.sql.ResultSet#refreshRow()
1042     */
1043    protected final void refreshRow() throws SQLException {
1044        rs.refreshRow();
1045    }
1046
1047    /**
1048     * @param rows
1049     * @return
1050     * @throws SQLException
1051     * @see java.sql.ResultSet#relative(int)
1052     */
1053    protected final boolean relative(final int rows) throws SQLException {
1054        return rs.relative(rows);
1055    }
1056
1057    /**
1058     * @return
1059     * @throws SQLException
1060     * @see java.sql.ResultSet#rowDeleted()
1061     */
1062    protected final boolean rowDeleted() throws SQLException {
1063        return rs.rowDeleted();
1064    }
1065
1066    /**
1067     * @return
1068     * @throws SQLException
1069     * @see java.sql.ResultSet#rowInserted()
1070     */
1071    protected final boolean rowInserted() throws SQLException {
1072        return rs.rowInserted();
1073    }
1074
1075    /**
1076     * @return
1077     * @throws SQLException
1078     * @see java.sql.ResultSet#rowUpdated()
1079     */
1080    protected final boolean rowUpdated() throws SQLException {
1081        return rs.rowUpdated();
1082    }
1083
1084    /**
1085     * @param direction
1086     * @throws SQLException
1087     * @see java.sql.ResultSet#setFetchDirection(int)
1088     */
1089    protected final void setFetchDirection(final int direction) throws SQLException {
1090        rs.setFetchDirection(direction);
1091    }
1092
1093    /**
1094     * @param rows
1095     * @throws SQLException
1096     * @see java.sql.ResultSet#setFetchSize(int)
1097     */
1098    protected final void setFetchSize(final int rows) throws SQLException {
1099        rs.setFetchSize(rows);
1100    }
1101
1102    /**
1103     * @param iface
1104     * @return
1105     * @throws SQLException
1106     * @see java.sql.Wrapper#unwrap(java.lang.Class)
1107     */
1108    protected final <E> E unwrap(final Class<E> iface) throws SQLException {
1109        return rs.unwrap(iface);
1110    }
1111
1112    /**
1113     * @param columnIndex
1114     * @param x
1115     * @throws SQLException
1116     * @see java.sql.ResultSet#updateArray(int, java.sql.Array)
1117     */
1118    protected final void updateArray(final int columnIndex, final Array x) throws SQLException {
1119        rs.updateArray(columnIndex, x);
1120    }
1121
1122    /**
1123     * @param columnLabel
1124     * @param x
1125     * @throws SQLException
1126     * @see java.sql.ResultSet#updateArray(java.lang.String, java.sql.Array)
1127     */
1128    protected final void updateArray(final String columnLabel, final Array x) throws SQLException {
1129        rs.updateArray(columnLabel, x);
1130    }
1131
1132    /**
1133     * @param columnIndex
1134     * @param x
1135     * @param length
1136     * @throws SQLException
1137     * @see java.sql.ResultSet#updateAsciiStream(int, java.io.InputStream, int)
1138     */
1139    protected final void updateAsciiStream(final int columnIndex, final InputStream x, final int length) throws SQLException {
1140        rs.updateAsciiStream(columnIndex, x, length);
1141    }
1142
1143    /**
1144     * @param columnIndex
1145     * @param x
1146     * @param length
1147     * @throws SQLException
1148     * @see java.sql.ResultSet#updateAsciiStream(int, java.io.InputStream, long)
1149     */
1150    protected final void updateAsciiStream(final int columnIndex, final InputStream x, final long length) throws SQLException {
1151        rs.updateAsciiStream(columnIndex, x, length);
1152    }
1153
1154    /**
1155     * @param columnIndex
1156     * @param x
1157     * @throws SQLException
1158     * @see java.sql.ResultSet#updateAsciiStream(int, java.io.InputStream)
1159     */
1160    protected final void updateAsciiStream(final int columnIndex, final InputStream x) throws SQLException {
1161        rs.updateAsciiStream(columnIndex, x);
1162    }
1163
1164    /**
1165     * @param columnLabel
1166     * @param x
1167     * @param length
1168     * @throws SQLException
1169     * @see java.sql.ResultSet#updateAsciiStream(java.lang.String, java.io.InputStream, int)
1170     */
1171    protected final void updateAsciiStream(final String columnLabel, final InputStream x, final int length) throws SQLException {
1172        rs.updateAsciiStream(columnLabel, x, length);
1173    }
1174
1175    /**
1176     * @param columnLabel
1177     * @param x
1178     * @param length
1179     * @throws SQLException
1180     * @see java.sql.ResultSet#updateAsciiStream(java.lang.String, java.io.InputStream, long)
1181     */
1182    protected final void updateAsciiStream(final String columnLabel, final InputStream x, final long length) throws SQLException {
1183        rs.updateAsciiStream(columnLabel, x, length);
1184    }
1185
1186    /**
1187     * @param columnLabel
1188     * @param x
1189     * @throws SQLException
1190     * @see java.sql.ResultSet#updateAsciiStream(java.lang.String, java.io.InputStream)
1191     */
1192    protected final void updateAsciiStream(final String columnLabel, final InputStream x) throws SQLException {
1193        rs.updateAsciiStream(columnLabel, x);
1194    }
1195
1196    /**
1197     * @param columnIndex
1198     * @param x
1199     * @throws SQLException
1200     * @see java.sql.ResultSet#updateBigDecimal(int, java.math.BigDecimal)
1201     */
1202    protected final void updateBigDecimal(final int columnIndex, final BigDecimal x) throws SQLException {
1203        rs.updateBigDecimal(columnIndex, x);
1204    }
1205
1206    /**
1207     * @param columnLabel
1208     * @param x
1209     * @throws SQLException
1210     * @see java.sql.ResultSet#updateBigDecimal(java.lang.String, java.math.BigDecimal)
1211     */
1212    protected final void updateBigDecimal(final String columnLabel, final BigDecimal x) throws SQLException {
1213        rs.updateBigDecimal(columnLabel, x);
1214    }
1215
1216    /**
1217     * @param columnIndex
1218     * @param x
1219     * @param length
1220     * @throws SQLException
1221     * @see java.sql.ResultSet#updateBinaryStream(int, java.io.InputStream, int)
1222     */
1223    protected final void updateBinaryStream(final int columnIndex, final InputStream x, final int length) throws SQLException {
1224        rs.updateBinaryStream(columnIndex, x, length);
1225    }
1226
1227    /**
1228     * @param columnIndex
1229     * @param x
1230     * @param length
1231     * @throws SQLException
1232     * @see java.sql.ResultSet#updateBinaryStream(int, java.io.InputStream, long)
1233     */
1234    protected final void updateBinaryStream(final int columnIndex, final InputStream x, final long length) throws SQLException {
1235        rs.updateBinaryStream(columnIndex, x, length);
1236    }
1237
1238    /**
1239     * @param columnIndex
1240     * @param x
1241     * @throws SQLException
1242     * @see java.sql.ResultSet#updateBinaryStream(int, java.io.InputStream)
1243     */
1244    protected final void updateBinaryStream(final int columnIndex, final InputStream x) throws SQLException {
1245        rs.updateBinaryStream(columnIndex, x);
1246    }
1247
1248    /**
1249     * @param columnLabel
1250     * @param x
1251     * @param length
1252     * @throws SQLException
1253     * @see java.sql.ResultSet#updateBinaryStream(java.lang.String, java.io.InputStream, int)
1254     */
1255    protected final void updateBinaryStream(final String columnLabel, final InputStream x, final int length) throws SQLException {
1256        rs.updateBinaryStream(columnLabel, x, length);
1257    }
1258
1259    /**
1260     * @param columnLabel
1261     * @param x
1262     * @param length
1263     * @throws SQLException
1264     * @see java.sql.ResultSet#updateBinaryStream(java.lang.String, java.io.InputStream, long)
1265     */
1266    protected final void updateBinaryStream(final String columnLabel, final InputStream x, final long length) throws SQLException {
1267        rs.updateBinaryStream(columnLabel, x, length);
1268    }
1269
1270    /**
1271     * @param columnLabel
1272     * @param x
1273     * @throws SQLException
1274     * @see java.sql.ResultSet#updateBinaryStream(java.lang.String, java.io.InputStream)
1275     */
1276    protected final void updateBinaryStream(final String columnLabel, final InputStream x) throws SQLException {
1277        rs.updateBinaryStream(columnLabel, x);
1278    }
1279
1280    /**
1281     * @param columnIndex
1282     * @param x
1283     * @throws SQLException
1284     * @see java.sql.ResultSet#updateBlob(int, java.sql.Blob)
1285     */
1286    protected final void updateBlob(final int columnIndex, final Blob x) throws SQLException {
1287        rs.updateBlob(columnIndex, x);
1288    }
1289
1290    /**
1291     * @param columnIndex
1292     * @param inputStream
1293     * @param length
1294     * @throws SQLException
1295     * @see java.sql.ResultSet#updateBlob(int, java.io.InputStream, long)
1296     */
1297    protected final void updateBlob(final int columnIndex, final InputStream inputStream, final long length) throws SQLException {
1298        rs.updateBlob(columnIndex, inputStream, length);
1299    }
1300
1301    /**
1302     * @param columnIndex
1303     * @param inputStream
1304     * @throws SQLException
1305     * @see java.sql.ResultSet#updateBlob(int, java.io.InputStream)
1306     */
1307    protected final void updateBlob(final int columnIndex, final InputStream inputStream) throws SQLException {
1308        rs.updateBlob(columnIndex, inputStream);
1309    }
1310
1311    /**
1312     * @param columnLabel
1313     * @param x
1314     * @throws SQLException
1315     * @see java.sql.ResultSet#updateBlob(java.lang.String, java.sql.Blob)
1316     */
1317    protected final void updateBlob(final String columnLabel, final Blob x) throws SQLException {
1318        rs.updateBlob(columnLabel, x);
1319    }
1320
1321    /**
1322     * @param columnLabel
1323     * @param inputStream
1324     * @param length
1325     * @throws SQLException
1326     * @see java.sql.ResultSet#updateBlob(java.lang.String, java.io.InputStream, long)
1327     */
1328    protected final void updateBlob(final String columnLabel, final InputStream inputStream, final long length) throws SQLException {
1329        rs.updateBlob(columnLabel, inputStream, length);
1330    }
1331
1332    /**
1333     * @param columnLabel
1334     * @param inputStream
1335     * @throws SQLException
1336     * @see java.sql.ResultSet#updateBlob(java.lang.String, java.io.InputStream)
1337     */
1338    protected final void updateBlob(final String columnLabel, final InputStream inputStream) throws SQLException {
1339        rs.updateBlob(columnLabel, inputStream);
1340    }
1341
1342    /**
1343     * @param columnIndex
1344     * @param x
1345     * @throws SQLException
1346     * @see java.sql.ResultSet#updateBoolean(int, boolean)
1347     */
1348    protected final void updateBoolean(final int columnIndex, final boolean x) throws SQLException {
1349        rs.updateBoolean(columnIndex, x);
1350    }
1351
1352    /**
1353     * @param columnLabel
1354     * @param x
1355     * @throws SQLException
1356     * @see java.sql.ResultSet#updateBoolean(java.lang.String, boolean)
1357     */
1358    protected final void updateBoolean(final String columnLabel, final boolean x) throws SQLException {
1359        rs.updateBoolean(columnLabel, x);
1360    }
1361
1362    /**
1363     * @param columnIndex
1364     * @param x
1365     * @throws SQLException
1366     * @see java.sql.ResultSet#updateByte(int, byte)
1367     */
1368    protected final void updateByte(final int columnIndex, final byte x) throws SQLException {
1369        rs.updateByte(columnIndex, x);
1370    }
1371
1372    /**
1373     * @param columnLabel
1374     * @param x
1375     * @throws SQLException
1376     * @see java.sql.ResultSet#updateByte(java.lang.String, byte)
1377     */
1378    protected final void updateByte(final String columnLabel, final byte x) throws SQLException {
1379        rs.updateByte(columnLabel, x);
1380    }
1381
1382    /**
1383     * @param columnIndex
1384     * @param x
1385     * @throws SQLException
1386     * @see java.sql.ResultSet#updateBytes(int, byte[])
1387     */
1388    protected final void updateBytes(final int columnIndex, final byte[] x) throws SQLException {
1389        rs.updateBytes(columnIndex, x);
1390    }
1391
1392    /**
1393     * @param columnLabel
1394     * @param x
1395     * @throws SQLException
1396     * @see java.sql.ResultSet#updateBytes(java.lang.String, byte[])
1397     */
1398    protected final void updateBytes(final String columnLabel, final byte[] x) throws SQLException {
1399        rs.updateBytes(columnLabel, x);
1400    }
1401
1402    /**
1403     * @param columnIndex
1404     * @param x
1405     * @param length
1406     * @throws SQLException
1407     * @see java.sql.ResultSet#updateCharacterStream(int, java.io.Reader, int)
1408     */
1409    protected final void updateCharacterStream(final int columnIndex, final Reader x, final int length) throws SQLException {
1410        rs.updateCharacterStream(columnIndex, x, length);
1411    }
1412
1413    /**
1414     * @param columnIndex
1415     * @param x
1416     * @param length
1417     * @throws SQLException
1418     * @see java.sql.ResultSet#updateCharacterStream(int, java.io.Reader, long)
1419     */
1420    protected final void updateCharacterStream(final int columnIndex, final Reader x, final long length) throws SQLException {
1421        rs.updateCharacterStream(columnIndex, x, length);
1422    }
1423
1424    /**
1425     * @param columnIndex
1426     * @param x
1427     * @throws SQLException
1428     * @see java.sql.ResultSet#updateCharacterStream(int, java.io.Reader)
1429     */
1430    protected final void updateCharacterStream(final int columnIndex, final Reader x) throws SQLException {
1431        rs.updateCharacterStream(columnIndex, x);
1432    }
1433
1434    /**
1435     * @param columnLabel
1436     * @param reader
1437     * @param length
1438     * @throws SQLException
1439     * @see java.sql.ResultSet#updateCharacterStream(java.lang.String, java.io.Reader, int)
1440     */
1441    protected final void updateCharacterStream(final String columnLabel, final Reader reader, final int length) throws SQLException {
1442        rs.updateCharacterStream(columnLabel, reader, length);
1443    }
1444
1445    /**
1446     * @param columnLabel
1447     * @param reader
1448     * @param length
1449     * @throws SQLException
1450     * @see java.sql.ResultSet#updateCharacterStream(java.lang.String, java.io.Reader, long)
1451     */
1452    protected final void updateCharacterStream(final String columnLabel, final Reader reader, final long length) throws SQLException {
1453        rs.updateCharacterStream(columnLabel, reader, length);
1454    }
1455
1456    /**
1457     * @param columnLabel
1458     * @param reader
1459     * @throws SQLException
1460     * @see java.sql.ResultSet#updateCharacterStream(java.lang.String, java.io.Reader)
1461     */
1462    protected final void updateCharacterStream(final String columnLabel, final Reader reader) throws SQLException {
1463        rs.updateCharacterStream(columnLabel, reader);
1464    }
1465
1466    /**
1467     * @param columnIndex
1468     * @param x
1469     * @throws SQLException
1470     * @see java.sql.ResultSet#updateClob(int, java.sql.Clob)
1471     */
1472    protected final void updateClob(final int columnIndex, final Clob x) throws SQLException {
1473        rs.updateClob(columnIndex, x);
1474    }
1475
1476    /**
1477     * @param columnIndex
1478     * @param reader
1479     * @param length
1480     * @throws SQLException
1481     * @see java.sql.ResultSet#updateClob(int, java.io.Reader, long)
1482     */
1483    protected final void updateClob(final int columnIndex, final Reader reader, final long length) throws SQLException {
1484        rs.updateClob(columnIndex, reader, length);
1485    }
1486
1487    /**
1488     * @param columnIndex
1489     * @param reader
1490     * @throws SQLException
1491     * @see java.sql.ResultSet#updateClob(int, java.io.Reader)
1492     */
1493    protected final void updateClob(final int columnIndex, final Reader reader) throws SQLException {
1494        rs.updateClob(columnIndex, reader);
1495    }
1496
1497    /**
1498     * @param columnLabel
1499     * @param x
1500     * @throws SQLException
1501     * @see java.sql.ResultSet#updateClob(java.lang.String, java.sql.Clob)
1502     */
1503    protected final void updateClob(final String columnLabel, final Clob x) throws SQLException {
1504        rs.updateClob(columnLabel, x);
1505    }
1506
1507    /**
1508     * @param columnLabel
1509     * @param reader
1510     * @param length
1511     * @throws SQLException
1512     * @see java.sql.ResultSet#updateClob(java.lang.String, java.io.Reader, long)
1513     */
1514    protected final void updateClob(final String columnLabel, final Reader reader, final long length) throws SQLException {
1515        rs.updateClob(columnLabel, reader, length);
1516    }
1517
1518    /**
1519     * @param columnLabel
1520     * @param reader
1521     * @throws SQLException
1522     * @see java.sql.ResultSet#updateClob(java.lang.String, java.io.Reader)
1523     */
1524    protected final void updateClob(final String columnLabel, final Reader reader) throws SQLException {
1525        rs.updateClob(columnLabel, reader);
1526    }
1527
1528    /**
1529     * @param columnIndex
1530     * @param x
1531     * @throws SQLException
1532     * @see java.sql.ResultSet#updateDate(int, java.sql.Date)
1533     */
1534    protected final void updateDate(final int columnIndex, final Date x) throws SQLException {
1535        rs.updateDate(columnIndex, x);
1536    }
1537
1538    /**
1539     * @param columnLabel
1540     * @param x
1541     * @throws SQLException
1542     * @see java.sql.ResultSet#updateDate(java.lang.String, java.sql.Date)
1543     */
1544    protected final void updateDate(final String columnLabel, final Date x) throws SQLException {
1545        rs.updateDate(columnLabel, x);
1546    }
1547
1548    /**
1549     * @param columnIndex
1550     * @param x
1551     * @throws SQLException
1552     * @see java.sql.ResultSet#updateDouble(int, double)
1553     */
1554    protected final void updateDouble(final int columnIndex, final double x) throws SQLException {
1555        rs.updateDouble(columnIndex, x);
1556    }
1557
1558    /**
1559     * @param columnLabel
1560     * @param x
1561     * @throws SQLException
1562     * @see java.sql.ResultSet#updateDouble(java.lang.String, double)
1563     */
1564    protected final void updateDouble(final String columnLabel, final double x) throws SQLException {
1565        rs.updateDouble(columnLabel, x);
1566    }
1567
1568    /**
1569     * @param columnIndex
1570     * @param x
1571     * @throws SQLException
1572     * @see java.sql.ResultSet#updateFloat(int, float)
1573     */
1574    protected final void updateFloat(final int columnIndex, final float x) throws SQLException {
1575        rs.updateFloat(columnIndex, x);
1576    }
1577
1578    /**
1579     * @param columnLabel
1580     * @param x
1581     * @throws SQLException
1582     * @see java.sql.ResultSet#updateFloat(java.lang.String, float)
1583     */
1584    protected final void updateFloat(final String columnLabel, final float x) throws SQLException {
1585        rs.updateFloat(columnLabel, x);
1586    }
1587
1588    /**
1589     * @param columnIndex
1590     * @param x
1591     * @throws SQLException
1592     * @see java.sql.ResultSet#updateInt(int, int)
1593     */
1594    protected final void updateInt(final int columnIndex, final int x) throws SQLException {
1595        rs.updateInt(columnIndex, x);
1596    }
1597
1598    /**
1599     * @param columnLabel
1600     * @param x
1601     * @throws SQLException
1602     * @see java.sql.ResultSet#updateInt(java.lang.String, int)
1603     */
1604    protected final void updateInt(final String columnLabel, final int x) throws SQLException {
1605        rs.updateInt(columnLabel, x);
1606    }
1607
1608    /**
1609     * @param columnIndex
1610     * @param x
1611     * @throws SQLException
1612     * @see java.sql.ResultSet#updateLong(int, long)
1613     */
1614    protected final void updateLong(final int columnIndex, final long x) throws SQLException {
1615        rs.updateLong(columnIndex, x);
1616    }
1617
1618    /**
1619     * @param columnLabel
1620     * @param x
1621     * @throws SQLException
1622     * @see java.sql.ResultSet#updateLong(java.lang.String, long)
1623     */
1624    protected final void updateLong(final String columnLabel, final long x) throws SQLException {
1625        rs.updateLong(columnLabel, x);
1626    }
1627
1628    /**
1629     * @param columnIndex
1630     * @param x
1631     * @param length
1632     * @throws SQLException
1633     * @see java.sql.ResultSet#updateNCharacterStream(int, java.io.Reader, long)
1634     */
1635    protected final void updateNCharacterStream(final int columnIndex, final Reader x, final long length) throws SQLException {
1636        rs.updateNCharacterStream(columnIndex, x, length);
1637    }
1638
1639    /**
1640     * @param columnIndex
1641     * @param x
1642     * @throws SQLException
1643     * @see java.sql.ResultSet#updateNCharacterStream(int, java.io.Reader)
1644     */
1645    protected final void updateNCharacterStream(final int columnIndex, final Reader x) throws SQLException {
1646        rs.updateNCharacterStream(columnIndex, x);
1647    }
1648
1649    /**
1650     * @param columnLabel
1651     * @param reader
1652     * @param length
1653     * @throws SQLException
1654     * @see java.sql.ResultSet#updateNCharacterStream(java.lang.String, java.io.Reader, long)
1655     */
1656    protected final void updateNCharacterStream(final String columnLabel, final Reader reader, final long length) throws SQLException {
1657        rs.updateNCharacterStream(columnLabel, reader, length);
1658    }
1659
1660    /**
1661     * @param columnLabel
1662     * @param reader
1663     * @throws SQLException
1664     * @see java.sql.ResultSet#updateNCharacterStream(java.lang.String, java.io.Reader)
1665     */
1666    protected final void updateNCharacterStream(final String columnLabel, final Reader reader) throws SQLException {
1667        rs.updateNCharacterStream(columnLabel, reader);
1668    }
1669
1670    /**
1671     * @param columnIndex
1672     * @param nClob
1673     * @throws SQLException
1674     * @see java.sql.ResultSet#updateNClob(int, java.sql.NClob)
1675     */
1676    protected final void updateNClob(final int columnIndex, final NClob nClob) throws SQLException {
1677        rs.updateNClob(columnIndex, nClob);
1678    }
1679
1680    /**
1681     * @param columnIndex
1682     * @param reader
1683     * @param length
1684     * @throws SQLException
1685     * @see java.sql.ResultSet#updateNClob(int, java.io.Reader, long)
1686     */
1687    protected final void updateNClob(final int columnIndex, final Reader reader, final long length) throws SQLException {
1688        rs.updateNClob(columnIndex, reader, length);
1689    }
1690
1691    /**
1692     * @param columnIndex
1693     * @param reader
1694     * @throws SQLException
1695     * @see java.sql.ResultSet#updateNClob(int, java.io.Reader)
1696     */
1697    protected final void updateNClob(final int columnIndex, final Reader reader) throws SQLException {
1698        rs.updateNClob(columnIndex, reader);
1699    }
1700
1701    /**
1702     * @param columnLabel
1703     * @param nClob
1704     * @throws SQLException
1705     * @see java.sql.ResultSet#updateNClob(java.lang.String, java.sql.NClob)
1706     */
1707    protected final void updateNClob(final String columnLabel, final NClob nClob) throws SQLException {
1708        rs.updateNClob(columnLabel, nClob);
1709    }
1710
1711    /**
1712     * @param columnLabel
1713     * @param reader
1714     * @param length
1715     * @throws SQLException
1716     * @see java.sql.ResultSet#updateNClob(java.lang.String, java.io.Reader, long)
1717     */
1718    protected final void updateNClob(final String columnLabel, final Reader reader, final long length) throws SQLException {
1719        rs.updateNClob(columnLabel, reader, length);
1720    }
1721
1722    /**
1723     * @param columnLabel
1724     * @param reader
1725     * @throws SQLException
1726     * @see java.sql.ResultSet#updateNClob(java.lang.String, java.io.Reader)
1727     */
1728    protected final void updateNClob(final String columnLabel, final Reader reader) throws SQLException {
1729        rs.updateNClob(columnLabel, reader);
1730    }
1731
1732    /**
1733     * @param columnIndex
1734     * @param nString
1735     * @throws SQLException
1736     * @see java.sql.ResultSet#updateNString(int, java.lang.String)
1737     */
1738    protected final void updateNString(final int columnIndex, final String nString) throws SQLException {
1739        rs.updateNString(columnIndex, nString);
1740    }
1741
1742    /**
1743     * @param columnLabel
1744     * @param nString
1745     * @throws SQLException
1746     * @see java.sql.ResultSet#updateNString(java.lang.String, java.lang.String)
1747     */
1748    protected final void updateNString(final String columnLabel, final String nString) throws SQLException {
1749        rs.updateNString(columnLabel, nString);
1750    }
1751
1752    /**
1753     * @param columnIndex
1754     * @throws SQLException
1755     * @see java.sql.ResultSet#updateNull(int)
1756     */
1757    protected final void updateNull(final int columnIndex) throws SQLException {
1758        rs.updateNull(columnIndex);
1759    }
1760
1761    /**
1762     * @param columnLabel
1763     * @throws SQLException
1764     * @see java.sql.ResultSet#updateNull(java.lang.String)
1765     */
1766    protected final void updateNull(final String columnLabel) throws SQLException {
1767        rs.updateNull(columnLabel);
1768    }
1769
1770    /**
1771     * @param columnIndex
1772     * @param x
1773     * @param scaleOrLength
1774     * @throws SQLException
1775     * @see java.sql.ResultSet#updateObject(int, java.lang.Object, int)
1776     */
1777    protected final void updateObject(final int columnIndex, final Object x, final int scaleOrLength) throws SQLException {
1778        rs.updateObject(columnIndex, x, scaleOrLength);
1779    }
1780
1781    /**
1782     * @param columnIndex
1783     * @param x
1784     * @throws SQLException
1785     * @see java.sql.ResultSet#updateObject(int, java.lang.Object)
1786     */
1787    protected final void updateObject(final int columnIndex, final Object x) throws SQLException {
1788        rs.updateObject(columnIndex, x);
1789    }
1790
1791    /**
1792     * @param columnLabel
1793     * @param x
1794     * @param scaleOrLength
1795     * @throws SQLException
1796     * @see java.sql.ResultSet#updateObject(java.lang.String, java.lang.Object, int)
1797     */
1798    protected final void updateObject(final String columnLabel, final Object x, final int scaleOrLength) throws SQLException {
1799        rs.updateObject(columnLabel, x, scaleOrLength);
1800    }
1801
1802    /**
1803     * @param columnLabel
1804     * @param x
1805     * @throws SQLException
1806     * @see java.sql.ResultSet#updateObject(java.lang.String, java.lang.Object)
1807     */
1808    protected final void updateObject(final String columnLabel, final Object x) throws SQLException {
1809        rs.updateObject(columnLabel, x);
1810    }
1811
1812    /**
1813     * @param columnIndex
1814     * @param x
1815     * @throws SQLException
1816     * @see java.sql.ResultSet#updateRef(int, java.sql.Ref)
1817     */
1818    protected final void updateRef(final int columnIndex, final Ref x) throws SQLException {
1819        rs.updateRef(columnIndex, x);
1820    }
1821
1822    /**
1823     * @param columnLabel
1824     * @param x
1825     * @throws SQLException
1826     * @see java.sql.ResultSet#updateRef(java.lang.String, java.sql.Ref)
1827     */
1828    protected final void updateRef(final String columnLabel, final Ref x) throws SQLException {
1829        rs.updateRef(columnLabel, x);
1830    }
1831
1832    /**
1833     * @throws SQLException
1834     * @see java.sql.ResultSet#updateRow()
1835     */
1836    protected final void updateRow() throws SQLException {
1837        rs.updateRow();
1838    }
1839
1840    /**
1841     * @param columnIndex
1842     * @param x
1843     * @throws SQLException
1844     * @see java.sql.ResultSet#updateRowId(int, java.sql.RowId)
1845     */
1846    protected final void updateRowId(final int columnIndex, final RowId x) throws SQLException {
1847        rs.updateRowId(columnIndex, x);
1848    }
1849
1850    /**
1851     * @param columnLabel
1852     * @param x
1853     * @throws SQLException
1854     * @see java.sql.ResultSet#updateRowId(java.lang.String, java.sql.RowId)
1855     */
1856    protected final void updateRowId(final String columnLabel, final RowId x) throws SQLException {
1857        rs.updateRowId(columnLabel, x);
1858    }
1859
1860    /**
1861     * @param columnIndex
1862     * @param xmlObject
1863     * @throws SQLException
1864     * @see java.sql.ResultSet#updateSQLXML(int, java.sql.SQLXML)
1865     */
1866    protected final void updateSQLXML(final int columnIndex, final SQLXML xmlObject) throws SQLException {
1867        rs.updateSQLXML(columnIndex, xmlObject);
1868    }
1869
1870    /**
1871     * @param columnLabel
1872     * @param xmlObject
1873     * @throws SQLException
1874     * @see java.sql.ResultSet#updateSQLXML(java.lang.String, java.sql.SQLXML)
1875     */
1876    protected final void updateSQLXML(final String columnLabel, final SQLXML xmlObject) throws SQLException {
1877        rs.updateSQLXML(columnLabel, xmlObject);
1878    }
1879
1880    /**
1881     * @param columnIndex
1882     * @param x
1883     * @throws SQLException
1884     * @see java.sql.ResultSet#updateShort(int, short)
1885     */
1886    protected final void updateShort(final int columnIndex, final short x) throws SQLException {
1887        rs.updateShort(columnIndex, x);
1888    }
1889
1890    /**
1891     * @param columnLabel
1892     * @param x
1893     * @throws SQLException
1894     * @see java.sql.ResultSet#updateShort(java.lang.String, short)
1895     */
1896    protected final void updateShort(final String columnLabel, final short x) throws SQLException {
1897        rs.updateShort(columnLabel, x);
1898    }
1899
1900    /**
1901     * @param columnIndex
1902     * @param x
1903     * @throws SQLException
1904     * @see java.sql.ResultSet#updateString(int, java.lang.String)
1905     */
1906    protected final void updateString(final int columnIndex, final String x) throws SQLException {
1907        rs.updateString(columnIndex, x);
1908    }
1909
1910    /**
1911     * @param columnLabel
1912     * @param x
1913     * @throws SQLException
1914     * @see java.sql.ResultSet#updateString(java.lang.String, java.lang.String)
1915     */
1916    protected final void updateString(final String columnLabel, final String x) throws SQLException {
1917        rs.updateString(columnLabel, x);
1918    }
1919
1920    /**
1921     * @param columnIndex
1922     * @param x
1923     * @throws SQLException
1924     * @see java.sql.ResultSet#updateTime(int, java.sql.Time)
1925     */
1926    protected final void updateTime(final int columnIndex, final Time x) throws SQLException {
1927        rs.updateTime(columnIndex, x);
1928    }
1929
1930    /**
1931     * @param columnLabel
1932     * @param x
1933     * @throws SQLException
1934     * @see java.sql.ResultSet#updateTime(java.lang.String, java.sql.Time)
1935     */
1936    protected final void updateTime(final String columnLabel, final Time x) throws SQLException {
1937        rs.updateTime(columnLabel, x);
1938    }
1939
1940    /**
1941     * @param columnIndex
1942     * @param x
1943     * @throws SQLException
1944     * @see java.sql.ResultSet#updateTimestamp(int, java.sql.Timestamp)
1945     */
1946    protected final void updateTimestamp(final int columnIndex, final Timestamp x) throws SQLException {
1947        rs.updateTimestamp(columnIndex, x);
1948    }
1949
1950    /**
1951     * @param columnLabel
1952     * @param x
1953     * @throws SQLException
1954     * @see java.sql.ResultSet#updateTimestamp(java.lang.String, java.sql.Timestamp)
1955     */
1956    protected final void updateTimestamp(final String columnLabel, final Timestamp x) throws SQLException {
1957        rs.updateTimestamp(columnLabel, x);
1958    }
1959
1960    /**
1961     * @return
1962     * @throws SQLException
1963     * @see java.sql.ResultSet#wasNull()
1964     */
1965    protected final boolean wasNull() throws SQLException {
1966        return rs.wasNull();
1967    }
1968
1969    protected final ResultSet getAdaptedResultSet() {
1970        return rs;
1971    }
1972
1973}