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