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