    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
    046 * simply call the corresponding method on the "delegate"
    047 * provided in my constructor.
    048 * <p>
    049 * Extends AbandonedTrace to implement result set tracking and
    050 * logging of code which created the ResultSet. Tracking the
    051 * ResultSet ensures that the Statement which created it can
    052 * close any open ResultSet's on Statement close.
    053 *
    054 * @author Glenn L. Nielsen
    055 * @author James House
    056 * @author Dirk Verbeeck
    057 * @since 2.0
    058 */
    059public final class DelegatingResultSet extends AbandonedTrace implements ResultSet {
    060
    061    /** My delegate. **/
    062    private final ResultSet _res;
    063
    064    /** The Statement that created me, if any. **/
    065    private Statement _stmt;
    066
    067    /** The Connection that created me, if any. **/
    068    private Connection _conn;
    069
    070    /**
    071     * Create a wrapper for the ResultSet which traces this
    072     * ResultSet to the Statement which created it and the
    073     * code which created it.
    074     * <p>
    075     * Private to ensure all construction is
    076     * {@link #wrapResultSet(Statement, ResultSet)}
    077     *
    078     * @param stmt Statement which created this ResultSet
    079     * @param res ResultSet to wrap
    080     */
    081    private DelegatingResultSet(final Statement stmt, final ResultSet res) {
    082        super((AbandonedTrace)stmt);
    083        this._stmt = stmt;
    084        this._res = res;
    085    }
    086
    087    /**
    088     * Create a wrapper for the ResultSet which traces this
    089     * ResultSet to the Connection which created it (via, for
    090     * example DatabaseMetadata, and the code which created it.
    091     * <p>
    092     * Private to ensure all construction is
    093     * {@link #wrapResultSet(Connection, ResultSet)}
    094     *
    095     * @param conn Connection which created this ResultSet
    096     * @param res ResultSet to wrap
    097     */
    098    private DelegatingResultSet(final Connection conn, final ResultSet res) {
    099        super((AbandonedTrace)conn);
    100        this._conn = conn;
    101        this._res = res;
    102    }
    103
    104    public static ResultSet wrapResultSet(final Statement stmt, final ResultSet rset) {
    105        if(null == rset) {
    106            return null;
    107        }
    108        return new DelegatingResultSet(stmt,rset);
    109    }
    110
    111    public static ResultSet wrapResultSet(final Connection conn, final ResultSet rset) {
    112        if(null == rset) {
    113            return null;
    114        }
    115        return new DelegatingResultSet(conn,rset);
    116    }
    117
    118    public ResultSet getDelegate() {
    119        return _res;
    120    }
    121
    122    /**
    123     * If my underlying {@link ResultSet} is not a
    124     * {@code DelegatingResultSet}, returns it,
    125     * otherwise recursively invokes this method on
    126     * my delegate.
    127     * <p>
    128     * Hence this method will return the first
    129     * delegate that is not a {@code DelegatingResultSet},
    130     * or {@code null} when no non-{@code DelegatingResultSet}
    131     * delegate can be found by traversing this chain.
    132     * <p>
    133     * This method is useful when you may have nested
    134     * {@code DelegatingResultSet}s, and you want to make
    135     * sure to obtain a "genuine" {@link ResultSet}.
    136     */
    137    public ResultSet getInnermostDelegate() {
    138        ResultSet r = _res;
    139        while(r != null && r instanceof DelegatingResultSet) {
    140            r = ((DelegatingResultSet)r).getDelegate();
    141            if(this == r) {
    142                return null;
    143            }
    144        }
    145        return r;
    146    }
    147
    148    @Override
    149    public Statement getStatement() throws SQLException {
    150        return _stmt;
    151    }
    152
    153    /**
    154     * Wrapper for close of ResultSet which removes this
    155     * result set from being traced then calls close on
    156     * the original ResultSet.
    157     */
    158    @Override
    159    public void close() throws SQLException {
    160        try {
    161            if(_stmt != null) {
    162                ((AbandonedTrace)_stmt).removeTrace(this);
    163                _stmt = null;
    164            }
    165            if(_conn != null) {
    166                ((AbandonedTrace)_conn).removeTrace(this);
    167                _conn = null;
    168            }
    169            _res.close();
    170        }
    171        catch (final SQLException e) {
    172            handleException(e);
    173        }
    174    }
    175
    176    protected void handleException(final SQLException e) throws SQLException {
    177        if (_stmt != null && _stmt instanceof DelegatingStatement) {
    178            ((DelegatingStatement)_stmt).handleException(e);
    179        }
    180        else if (_conn != null && _conn instanceof DelegatingConnection) {
    181            ((DelegatingConnection<?>)_conn).handleException(e);
    182        }
    183        else {
    184            throw e;
    185        }
    186    }
    187
    188    @Override
    189    public boolean next() throws SQLException
    190    { try { return _res.next(); } catch (final SQLException e) { handleException(e); return false; } }
    191
    192    @Override
    193    public boolean wasNull() throws SQLException
    194    { try { return _res.wasNull(); } catch (final SQLException e) { handleException(e); return false; } }
    195
    196    @Override
    197    public String getString(final int columnIndex) throws SQLException
    198    { try { return _res.getString(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
    199
    200    @Override
    201    public boolean getBoolean(final int columnIndex) throws SQLException
    202    { try { return _res.getBoolean(columnIndex); } catch (final SQLException e) { handleException(e); return false; } }
    203
    204    @Override
    205    public byte getByte(final int columnIndex) throws SQLException
    206    { try { return _res.getByte(columnIndex); } catch (final SQLException e) { handleException(e); return 0; } }
    207
    208    @Override
    209    public short getShort(final int columnIndex) throws SQLException
    210    { try { return _res.getShort(columnIndex); } catch (final SQLException e) { handleException(e); return 0; } }
    211
    212    @Override
    213    public int getInt(final int columnIndex) throws SQLException
    214    { try { return _res.getInt(columnIndex); } catch (final SQLException e) { handleException(e); return 0; } }
    215
    216    @Override
    217    public long getLong(final int columnIndex) throws SQLException
    218    { try { return _res.getLong(columnIndex); } catch (final SQLException e) { handleException(e); return 0; } }
    219
    220    @Override
    221    public float getFloat(final int columnIndex) throws SQLException
    222    { try { return _res.getFloat(columnIndex); } catch (final SQLException e) { handleException(e); return 0; } }
    223
    224    @Override
    225    public double getDouble(final int columnIndex) throws SQLException
    226    { try { return _res.getDouble(columnIndex); } catch (final SQLException e) { handleException(e); return 0; } }
    227
    228    /** @deprecated Use {@link #getBigDecimal(int)} */
    229    @Deprecated
    230    @Override
    231    public BigDecimal getBigDecimal(final int columnIndex, final int scale) throws SQLException
    232    { try { return _res.getBigDecimal(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
    233
    234    @Override
    235    public byte[] getBytes(final int columnIndex) throws SQLException
    236    { try { return _res.getBytes(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
    237
    238    @Override
    239    public Date getDate(final int columnIndex) throws SQLException
    240    { try { return _res.getDate(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
    241
    242    @Override
    243    public Time getTime(final int columnIndex) throws SQLException
    244    { try { return _res.getTime(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
    245
    246    @Override
    247    public Timestamp getTimestamp(final int columnIndex) throws SQLException
    248    { try { return _res.getTimestamp(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
    249
    250    @Override
    251    public InputStream getAsciiStream(final int columnIndex) throws SQLException
    252    { try { return _res.getAsciiStream(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
    253
    254    /** @deprecated Use {@link #getCharacterStream(int)} */
    255    @Deprecated
    256    @Override
    257    public InputStream getUnicodeStream(final int columnIndex) throws SQLException
    258    { try { return _res.getUnicodeStream(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
    259
    260    @Override
    261    public InputStream getBinaryStream(final int columnIndex) throws SQLException
    262    { try { return _res.getBinaryStream(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
    263
    264    @Override
    265    public String getString(final String columnName) throws SQLException
    266    { try { return _res.getString(columnName); } catch (final SQLException e) { handleException(e); return null; } }
    267
    268    @Override
    269    public boolean getBoolean(final String columnName) throws SQLException
    270    { try { return _res.getBoolean(columnName); } catch (final SQLException e) { handleException(e); return false; } }
    271
    272    @Override
    273    public byte getByte(final String columnName) throws SQLException
    274    { try { return _res.getByte(columnName); } catch (final SQLException e) { handleException(e); return 0; } }
    275
    276    @Override
    277    public short getShort(final String columnName) throws SQLException
    278    { try { return _res.getShort(columnName); } catch (final SQLException e) { handleException(e); return 0; } }
    279
    280    @Override
    281    public int getInt(final String columnName) throws SQLException
    282    { try { return _res.getInt(columnName); } catch (final SQLException e) { handleException(e); return 0; } }
    283
    284    @Override
    285    public long getLong(final String columnName) throws SQLException
    286    { try { return _res.getLong(columnName); } catch (final SQLException e) { handleException(e); return 0; } }
    287
    288    @Override
    289    public float getFloat(final String columnName) throws SQLException
    290    { try { return _res.getFloat(columnName); } catch (final SQLException e) { handleException(e); return 0; } }
    291
    292    @Override
    293    public double getDouble(final String columnName) throws SQLException
    294    { try { return _res.getDouble(columnName); } catch (final SQLException e) { handleException(e); return 0; } }
    295
    296    /** @deprecated Use {@link #getBigDecimal(String)} */
    297    @Deprecated
    298    @Override
    299    public BigDecimal getBigDecimal(final String columnName, final int scale) throws SQLException
    300    { try { return _res.getBigDecimal(columnName); } catch (final SQLException e) { handleException(e); return null; } }
    301
    302    @Override
    303    public byte[] getBytes(final String columnName) throws SQLException
    304    { try { return _res.getBytes(columnName); } catch (final SQLException e) { handleException(e); return null; } }
    305
    306    @Override
    307    public Date getDate(final String columnName) throws SQLException
    308    { try { return _res.getDate(columnName); } catch (final SQLException e) { handleException(e); return null; } }
    309
    310    @Override
    311    public Time getTime(final String columnName) throws SQLException
    312    { try { return _res.getTime(columnName); } catch (final SQLException e) { handleException(e); return null; } }
    313
    314    @Override
    315    public Timestamp getTimestamp(final String columnName) throws SQLException
    316    { try { return _res.getTimestamp(columnName); } catch (final SQLException e) { handleException(e); return null; } }
    317
    318    @Override
    319    public InputStream getAsciiStream(final String columnName) throws SQLException
    320    { try { return _res.getAsciiStream(columnName); } catch (final SQLException e) { handleException(e); return null; } }
    321
    322    /** @deprecated Use {@link #getCharacterStream(String)} */
    323    @Deprecated
    324    @Override
    325    public InputStream getUnicodeStream(final String columnName) throws SQLException
    326    { try { return _res.getUnicodeStream(columnName); } catch (final SQLException e) { handleException(e); return null; } }
    327
    328    @Override
    329    public InputStream getBinaryStream(final String columnName) throws SQLException
    330    { try { return _res.getBinaryStream(columnName); } catch (final SQLException e) { handleException(e); return null; } }
    331
    332    @Override
    333    public SQLWarning getWarnings() throws SQLException
    334    { try { return _res.getWarnings(); } catch (final SQLException e) { handleException(e); return null; } }
    335
    336    @Override
    337    public void clearWarnings() throws SQLException
    338    { try { _res.clearWarnings(); } catch (final SQLException e) { handleException(e); } }
    339
    340    @Override
    341    public String getCursorName() throws SQLException
    342    { try { return _res.getCursorName(); } catch (final SQLException e) { handleException(e); return null; } }
    343
    344    @Override
    345    public ResultSetMetaData getMetaData() throws SQLException
    346    { try { return _res.getMetaData(); } catch (final SQLException e) { handleException(e); return null; } }
    347
    348    @Override
    349    public Object getObject(final int columnIndex) throws SQLException
    350    { try { return _res.getObject(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
    351
    352    @Override
    353    public Object getObject(final String columnName) throws SQLException
    354    { try { return _res.getObject(columnName); } catch (final SQLException e) { handleException(e); return null; } }
    355
    356    @Override
    357    public int findColumn(final String columnName) throws SQLException
    358    { try { return _res.findColumn(columnName); } catch (final SQLException e) { handleException(e); return 0; } }
    359
    360    @Override
    361    public Reader getCharacterStream(final int columnIndex) throws SQLException
    362    { try { return _res.getCharacterStream(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
    363
    364    @Override
    365    public Reader getCharacterStream(final String columnName) throws SQLException
    366    { try { return _res.getCharacterStream(columnName); } catch (final SQLException e) { handleException(e); return null; } }
    367
    368    @Override
    369    public BigDecimal getBigDecimal(final int columnIndex) throws SQLException
    370    { try { return _res.getBigDecimal(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
    371
    372    @Override
    373    public BigDecimal getBigDecimal(final String columnName) throws SQLException
    374    { try { return _res.getBigDecimal(columnName); } catch (final SQLException e) { handleException(e); return null; } }
    375
    376    @Override
    377    public boolean isBeforeFirst() throws SQLException
    378    { try { return _res.isBeforeFirst(); } catch (final SQLException e) { handleException(e); return false; } }
    379
    380    @Override
    381    public boolean isAfterLast() throws SQLException
    382    { try { return _res.isAfterLast(); } catch (final SQLException e) { handleException(e); return false; } }
    383
    384    @Override
    385    public boolean isFirst() throws SQLException
    386    { try { return _res.isFirst(); } catch (final SQLException e) { handleException(e); return false; } }
    387
    388    @Override
    389    public boolean isLast() throws SQLException
    390    { try { return _res.isLast(); } catch (final SQLException e) { handleException(e); return false; } }
    391
    392    @Override
    393    public void beforeFirst() throws SQLException
    394    { try { _res.beforeFirst(); } catch (final SQLException e) { handleException(e); } }
    395
    396    @Override
    397    public void afterLast() throws SQLException
    398    { try { _res.afterLast(); } catch (final SQLException e) { handleException(e); } }
    399
    400    @Override
    401    public boolean first() throws SQLException
    402    { try { return _res.first(); } catch (final SQLException e) { handleException(e); return false; } }
    403
    404    @Override
    405    public boolean last() throws SQLException
    406    { try { return _res.last(); } catch (final SQLException e) { handleException(e); return false; } }
    407
    408    @Override
    409    public int getRow() throws SQLException
    410    { try { return _res.getRow(); } catch (final SQLException e) { handleException(e); return 0; } }
    411
    412    @Override
    413    public boolean absolute(final int row) throws SQLException
    414    { try { return _res.absolute(row); } catch (final SQLException e) { handleException(e); return false; } }
    415
    416    @Override
    417    public boolean relative(final int rows) throws SQLException
    418    { try { return _res.relative(rows); } catch (final SQLException e) { handleException(e); return false; } }
    419
    420    @Override
    421    public boolean previous() throws SQLException
    422    { try { return _res.previous(); } catch (final SQLException e) { handleException(e); return false; } }
    423
    424    @Override
    425    public void setFetchDirection(final int direction) throws SQLException
    426    { try { _res.setFetchDirection(direction); } catch (final SQLException e) { handleException(e); } }
    427
    428    @Override
    429    public int getFetchDirection() throws SQLException
    430    { try { return _res.getFetchDirection(); } catch (final SQLException e) { handleException(e); return 0; } }
    431
    432    @Override
    433    public void setFetchSize(final int rows) throws SQLException
    434    { try { _res.setFetchSize(rows); } catch (final SQLException e) { handleException(e); } }
    435
    436    @Override
    437    public int getFetchSize() throws SQLException
    438    { try { return _res.getFetchSize(); } catch (final SQLException e) { handleException(e); return 0; } }
    439
    440    @Override
    441    public int getType() throws SQLException
    442    { try { return _res.getType(); } catch (final SQLException e) { handleException(e); return 0; } }
    443
    444    @Override
    445    public int getConcurrency() throws SQLException
    446    { try { return _res.getConcurrency(); } catch (final SQLException e) { handleException(e); return 0; } }
    447
    448    @Override
    449    public boolean rowUpdated() throws SQLException
    450    { try { return _res.rowUpdated(); } catch (final SQLException e) { handleException(e); return false; } }
    451
    452    @Override
    453    public boolean rowInserted() throws SQLException
    454    { try { return _res.rowInserted(); } catch (final SQLException e) { handleException(e); return false; } }
    455
    456    @Override
    457    public boolean rowDeleted() throws SQLException
    458    { try { return _res.rowDeleted(); } catch (final SQLException e) { handleException(e); return false; } }
    459
    460    @Override
    461    public void updateNull(final int columnIndex) throws SQLException
    462    { try { _res.updateNull(columnIndex); } catch (final SQLException e) { handleException(e); } }
    463
    464    @Override
    465    public void updateBoolean(final int columnIndex, final boolean x) throws SQLException
    466    { try { _res.updateBoolean(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
    467
    468    @Override
    469    public void updateByte(final int columnIndex, final byte x) throws SQLException
    470    { try { _res.updateByte(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
    471
    472    @Override
    473    public void updateShort(final int columnIndex, final short x) throws SQLException
    474    { try { _res.updateShort(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
    475
    476    @Override
    477    public void updateInt(final int columnIndex, final int x) throws SQLException
    478    { try { _res.updateInt(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
    479
    480    @Override
    481    public void updateLong(final int columnIndex, final long x) throws SQLException
    482    { try { _res.updateLong(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
    483
    484    @Override
    485    public void updateFloat(final int columnIndex, final float x) throws SQLException
    486    { try { _res.updateFloat(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
    487
    488    @Override
    489    public void updateDouble(final int columnIndex, final double x) throws SQLException
    490    { try { _res.updateDouble(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
    491
    492    @Override
    493    public void updateBigDecimal(final int columnIndex, final BigDecimal x) throws SQLException
    494    { try { _res.updateBigDecimal(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
    495
    496    @Override
    497    public void updateString(final int columnIndex, final String x) throws SQLException
    498    { try { _res.updateString(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
    499
    500    @Override
    501    public void updateBytes(final int columnIndex, final byte[] x) throws SQLException
    502    { try { _res.updateBytes(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
    503
    504    @Override
    505    public void updateDate(final int columnIndex, final Date x) throws SQLException
    506    { try { _res.updateDate(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
    507
    508    @Override
    509    public void updateTime(final int columnIndex, final Time x) throws SQLException
    510    { try { _res.updateTime(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
    511
    512    @Override
    513    public void updateTimestamp(final int columnIndex, final Timestamp x) throws SQLException
    514    { try { _res.updateTimestamp(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
    515
    516    @Override
    517    public void updateAsciiStream(final int columnIndex, final InputStream x, final int length) throws SQLException
    518    { try { _res.updateAsciiStream(columnIndex, x, length); } catch (final SQLException e) { handleException(e); } }
    519
    520    @Override
    521    public void updateBinaryStream(final int columnIndex, final InputStream x, final int length) throws SQLException
    522    { try { _res.updateBinaryStream(columnIndex, x, length); } catch (final SQLException e) { handleException(e); } }
    523
    524    @Override
    525    public void updateCharacterStream(final int columnIndex, final Reader x, final int length) throws SQLException
    526    { try { _res.updateCharacterStream(columnIndex, x, length); } catch (final SQLException e) { handleException(e); } }
    527
    528    @Override
    529    public void updateObject(final int columnIndex, final Object x, final int scale) throws SQLException
    530    { try { _res.updateObject(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
    531
    532    @Override
    533    public void updateObject(final int columnIndex, final Object x) throws SQLException
    534    { try { _res.updateObject(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
    535
    536    @Override
    537    public void updateNull(final String columnName) throws SQLException
    538    { try { _res.updateNull(columnName); } catch (final SQLException e) { handleException(e); } }
    539
    540    @Override
    541    public void updateBoolean(final String columnName, final boolean x) throws SQLException
    542    { try { _res.updateBoolean(columnName, x); } catch (final SQLException e) { handleException(e); } }
    543
    544    @Override
    545    public void updateByte(final String columnName, final byte x) throws SQLException
    546    { try { _res.updateByte(columnName, x); } catch (final SQLException e) { handleException(e); } }
    547
    548    @Override
    549    public void updateShort(final String columnName, final short x) throws SQLException
    550    { try { _res.updateShort(columnName, x); } catch (final SQLException e) { handleException(e); } }
    551
    552    @Override
    553    public void updateInt(final String columnName, final int x) throws SQLException
    554    { try { _res.updateInt(columnName, x); } catch (final SQLException e) { handleException(e); } }
    555
    556    @Override
    557    public void updateLong(final String columnName, final long x) throws SQLException
    558    { try { _res.updateLong(columnName, x); } catch (final SQLException e) { handleException(e); } }
    559
    560    @Override
    561    public void updateFloat(final String columnName, final float x) throws SQLException
    562    { try { _res.updateFloat(columnName, x); } catch (final SQLException e) { handleException(e); } }
    563
    564    @Override
    565    public void updateDouble(final String columnName, final double x) throws SQLException
    566    { try { _res.updateDouble(columnName, x); } catch (final SQLException e) { handleException(e); } }
    567
    568    @Override
    569    public void updateBigDecimal(final String columnName, final BigDecimal x) throws SQLException
    570    { try { _res.updateBigDecimal(columnName, x); } catch (final SQLException e) { handleException(e); } }
    571
    572    @Override
    573    public void updateString(final String columnName, final String x) throws SQLException
    574    { try { _res.updateString(columnName, x); } catch (final SQLException e) { handleException(e); } }
    575
    576    @Override
    577    public void updateBytes(final String columnName, final byte[] x) throws SQLException
    578    { try { _res.updateBytes(columnName, x); } catch (final SQLException e) { handleException(e); } }
    579
    580    @Override
    581    public void updateDate(final String columnName, final Date x) throws SQLException
    582    { try { _res.updateDate(columnName, x); } catch (final SQLException e) { handleException(e); } }
    583
    584    @Override
    585    public void updateTime(final String columnName, final Time x) throws SQLException
    586    { try { _res.updateTime(columnName, x); } catch (final SQLException e) { handleException(e); } }
    587
    588    @Override
    589    public void updateTimestamp(final String columnName, final Timestamp x) throws SQLException
    590    { try { _res.updateTimestamp(columnName, x); } catch (final SQLException e) { handleException(e); } }
    591
    592    @Override
    593    public void updateAsciiStream(final String columnName, final InputStream x, final int length) throws SQLException
    594    { try { _res.updateAsciiStream(columnName, x, length); } catch (final SQLException e) { handleException(e); } }
    595
    596    @Override
    597    public void updateBinaryStream(final String columnName, final InputStream x, final int length) throws SQLException
    598    { try { _res.updateBinaryStream(columnName, x, length); } catch (final SQLException e) { handleException(e); } }
    599
    600    @Override
    601    public void updateCharacterStream(final String columnName, final Reader reader, final int length) throws SQLException
    602    { try { _res.updateCharacterStream(columnName, reader, length); } catch (final SQLException e) { handleException(e); } }
    603
    604    @Override
    605    public void updateObject(final String columnName, final Object x, final int scale) throws SQLException
    606    { try { _res.updateObject(columnName, x); } catch (final SQLException e) { handleException(e); } }
    607
    608    @Override
    609    public void updateObject(final String columnName, final Object x) throws SQLException
    610    { try { _res.updateObject(columnName, x); } catch (final SQLException e) { handleException(e); } }
    611
    612    @Override
    613    public void insertRow() throws SQLException
    614    { try { _res.insertRow(); } catch (final SQLException e) { handleException(e); } }
    615
    616    @Override
    617    public void updateRow() throws SQLException
    618    { try { _res.updateRow(); } catch (final SQLException e) { handleException(e); } }
    619
    620    @Override
    621    public void deleteRow() throws SQLException
    622    { try { _res.deleteRow(); } catch (final SQLException e) { handleException(e); } }
    623
    624    @Override
    625    public void refreshRow() throws SQLException
    626    { try { _res.refreshRow(); } catch (final SQLException e) { handleException(e); } }
    627
    628    @Override
    629    public void cancelRowUpdates() throws SQLException
    630    { try { _res.cancelRowUpdates(); } catch (final SQLException e) { handleException(e); } }
    631
    632    @Override
    633    public void moveToInsertRow() throws SQLException
    634    { try { _res.moveToInsertRow(); } catch (final SQLException e) { handleException(e); } }
    635
    636    @Override
    637    public void moveToCurrentRow() throws SQLException
    638    { try { _res.moveToCurrentRow(); } catch (final SQLException e) { handleException(e); } }
    639
    640    @Override
    641    public Object getObject(final int i, final Map<String,Class<?>> map) throws SQLException
    642    { try { return _res.getObject(i, map); } catch (final SQLException e) { handleException(e); return null; } }
    643
    644    @Override
    645    public Ref getRef(final int i) throws SQLException
    646    { try { return _res.getRef(i); } catch (final SQLException e) { handleException(e); return null; } }
    647
    648    @Override
    649    public Blob getBlob(final int i) throws SQLException
    650    { try { return _res.getBlob(i); } catch (final SQLException e) { handleException(e); return null; } }
    651
    652    @Override
    653    public Clob getClob(final int i) throws SQLException
    654    { try { return _res.getClob(i); } catch (final SQLException e) { handleException(e); return null; } }
    655
    656    @Override
    657    public Array getArray(final int i) throws SQLException
    658    { try { return _res.getArray(i); } catch (final SQLException e) { handleException(e); return null; } }
    659
    660    @Override
    661    public Object getObject(final String colName, final Map<String,Class<?>> map) throws SQLException
    662    { try { return _res.getObject(colName, map); } catch (final SQLException e) { handleException(e); return null; } }
    663
    664    @Override
    665    public Ref getRef(final String colName) throws SQLException
    666    { try { return _res.getRef(colName); } catch (final SQLException e) { handleException(e); return null; } }
    667
    668    @Override
    669    public Blob getBlob(final String colName) throws SQLException
    670    { try { return _res.getBlob(colName); } catch (final SQLException e) { handleException(e); return null; } }
    671
    672    @Override
    673    public Clob getClob(final String colName) throws SQLException
    674    { try { return _res.getClob(colName); } catch (final SQLException e) { handleException(e); return null; } }
    675
    676    @Override
    677    public Array getArray(final String colName) throws SQLException
    678    { try { return _res.getArray(colName); } catch (final SQLException e) { handleException(e); return null; } }
    679
    680    @Override
    681    public Date getDate(final int columnIndex, final Calendar cal) throws SQLException
    682    { try { return _res.getDate(columnIndex, cal); } catch (final SQLException e) { handleException(e); return null; } }
    683
    684    @Override
    685    public Date getDate(final String columnName, final Calendar cal) throws SQLException
    686    { try { return _res.getDate(columnName, cal); } catch (final SQLException e) { handleException(e); return null; } }
    687
    688    @Override
    689    public Time getTime(final int columnIndex, final Calendar cal) throws SQLException
    690    { try { return _res.getTime(columnIndex, cal); } catch (final SQLException e) { handleException(e); return null; } }
    691
    692    @Override
    693    public Time getTime(final String columnName, final Calendar cal) throws SQLException
    694    { try { return _res.getTime(columnName, cal); } catch (final SQLException e) { handleException(e); return null; } }
    695
    696    @Override
    697    public Timestamp getTimestamp(final int columnIndex, final Calendar cal) throws SQLException
    698    { try { return _res.getTimestamp(columnIndex, cal); } catch (final SQLException e) { handleException(e); return null; } }
    699
    700    @Override
    701    public Timestamp getTimestamp(final String columnName, final Calendar cal) throws SQLException
    702    { try { return _res.getTimestamp(columnName, cal); } catch (final SQLException e) { handleException(e); return null; } }
    703
    704
    705    @Override
    706    public java.net.URL getURL(final int columnIndex) throws SQLException
    707    { try { return _res.getURL(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
    708
    709    @Override
    710    public java.net.URL getURL(final String columnName) throws SQLException
    711    { try { return _res.getURL(columnName); } catch (final SQLException e) { handleException(e); return null; } }
    712
    713    @Override
    714    public void updateRef(final int columnIndex, final Ref x) throws SQLException
    715    { try { _res.updateRef(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
    716
    717    @Override
    718    public void updateRef(final String columnName, final Ref x) throws SQLException
    719    { try { _res.updateRef(columnName, x); } catch (final SQLException e) { handleException(e); } }
    720
    721    @Override
    722    public void updateBlob(final int columnIndex, final Blob x) throws SQLException
    723    { try { _res.updateBlob(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
    724
    725    @Override
    726    public void updateBlob(final String columnName, final Blob x) throws SQLException
    727    { try { _res.updateBlob(columnName, x); } catch (final SQLException e) { handleException(e); } }
    728
    729    @Override
    730    public void updateClob(final int columnIndex, final Clob x) throws SQLException
    731    { try { _res.updateClob(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
    732
    733    @Override
    734    public void updateClob(final String columnName, final Clob x) throws SQLException
    735    { try { _res.updateClob(columnName, x); } catch (final SQLException e) { handleException(e); } }
    736
    737    @Override
    738    public void updateArray(final int columnIndex, final Array x) throws SQLException
    739    { try { _res.updateArray(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
    740
    741    @Override
    742    public void updateArray(final String columnName, final Array x) throws SQLException
    743    { try { _res.updateArray(columnName, x); } catch (final SQLException e) { handleException(e); } }
    744
    745
    746    @Override
    747    public boolean isWrapperFor(final Class<?> iface) throws SQLException {
    748        if (iface.isAssignableFrom(getClass())) {
    749            return true;
    750        } else if (iface.isAssignableFrom(_res.getClass())) {
    751            return true;
    752        } else {
    753            return _res.isWrapperFor(iface);
    754        }
    755    }
    756
    757    @Override
    758    public <T> T unwrap(final Class<T> iface) throws SQLException {
    759        if (iface.isAssignableFrom(getClass())) {
    760            return iface.cast(this);
    761        } else if (iface.isAssignableFrom(_res.getClass())) {
    762            return iface.cast(_res);
    763        } else {
    764            return _res.unwrap(iface);
    765        }
    766    }
    767
    768    @Override
    769    public RowId getRowId(final int columnIndex) throws SQLException {
    770        try {
    771            return _res.getRowId(columnIndex);
    772        }
    773        catch (final SQLException e) {
    774            handleException(e);
    775            return null;
    776        }
    777    }
    778
    779    @Override
    780    public RowId getRowId(final String columnLabel) throws SQLException {
    781        try {
    782            return _res.getRowId(columnLabel);
    783        }
    784        catch (final SQLException e) {
    785            handleException(e);
    786            return null;
    787        }
    788    }
    789
    790    @Override
    791    public void updateRowId(final int columnIndex, final RowId value) throws SQLException {
    792        try {
    793            _res.updateRowId(columnIndex, value);
    794        }
    795        catch (final SQLException e) {
    796            handleException(e);
    797        }
    798    }
    799
    800    @Override
    801    public void updateRowId(final String columnLabel, final RowId value) throws SQLException {
    802        try {
    803            _res.updateRowId(columnLabel, value);
    804        }
    805        catch (final SQLException e) {
    806            handleException(e);
    807        }
    808    }
    809
    810    @Override
    811    public int getHoldability() throws SQLException {
    812        try {
    813            return _res.getHoldability();
    814        }
    815        catch (final SQLException e) {
    816            handleException(e);
    817            return 0;
    818        }
    819    }
    820
    821    @Override
    822    public boolean isClosed() throws SQLException {
    823        try {
    824            return _res.isClosed();
    825        }
    826        catch (final SQLException e) {
    827            handleException(e);
    828            return false;
    829        }
    830    }
    831
    832    @Override
    833    public void updateNString(final int columnIndex, final String value) throws SQLException {
    834        try {
    835            _res.updateNString(columnIndex, value);
    836        }
    837        catch (final SQLException e) {
    838            handleException(e);
    839        }
    840    }
    841
    842    @Override
    843    public void updateNString(final String columnLabel, final String value) throws SQLException {
    844        try {
    845            _res.updateNString(columnLabel, value);
    846        }
    847        catch (final SQLException e) {
    848            handleException(e);
    849        }
    850    }
    851
    852    @Override
    853    public void updateNClob(final int columnIndex, final NClob value) throws SQLException {
    854        try {
    855            _res.updateNClob(columnIndex, value);
    856        }
    857        catch (final SQLException e) {
    858            handleException(e);
    859        }
    860    }
    861
    862    @Override
    863    public void updateNClob(final String columnLabel, final NClob value) throws SQLException {
    864        try {
    865            _res.updateNClob(columnLabel, value);
    866        }
    867        catch (final SQLException e) {
    868            handleException(e);
    869        }
    870    }
    871
    872    @Override
    873    public NClob getNClob(final int columnIndex) throws SQLException {
    874        try {
    875            return _res.getNClob(columnIndex);
    876        }
    877        catch (final SQLException e) {
    878            handleException(e);
    879            return null;
    880        }
    881    }
    882
    883    @Override
    884    public NClob getNClob(final String columnLabel) throws SQLException {
    885        try {
    886            return _res.getNClob(columnLabel);
    887        }
    888        catch (final SQLException e) {
    889            handleException(e);
    890            return null;
    891        }
    892    }
    893
    894    @Override
    895    public SQLXML getSQLXML(final int columnIndex) throws SQLException {
    896        try {
    897            return _res.getSQLXML(columnIndex);
    898        }
    899        catch (final SQLException e) {
    900            handleException(e);
    901            return null;
    902        }
    903    }
    904
    905    @Override
    906    public SQLXML getSQLXML(final String columnLabel) throws SQLException {
    907        try {
    908            return _res.getSQLXML(columnLabel);
    909        }
    910        catch (final SQLException e) {
    911            handleException(e);
    912            return null;
    913        }
    914    }
    915
    916    @Override
    917    public void updateSQLXML(final int columnIndex, final SQLXML value) throws SQLException {
    918        try {
    919            _res.updateSQLXML(columnIndex, value);
    920        }
    921        catch (final SQLException e) {
    922            handleException(e);
    923        }
    924    }
    925
    926    @Override
    927    public void updateSQLXML(final String columnLabel, final SQLXML value) throws SQLException {
    928        try {
    929            _res.updateSQLXML(columnLabel, value);
    930        }
    931        catch (final SQLException e) {
    932            handleException(e);
    933        }
    934    }
    935
    936    @Override
    937    public String getNString(final int columnIndex) throws SQLException {
    938        try {
    939            return _res.getNString(columnIndex);
    940        }
    941        catch (final SQLException e) {
    942            handleException(e);
    943            return null;
    944        }
    945    }
    946
    947    @Override
    948    public String getNString(final String columnLabel) throws SQLException {
    949        try {
    950            return _res.getNString(columnLabel);
    951        }
    952        catch (final SQLException e) {
    953            handleException(e);
    954            return null;
    955        }
    956    }
    957
    958    @Override
    959    public Reader getNCharacterStream(final int columnIndex) throws SQLException {
    960        try {
    961            return _res.getNCharacterStream(columnIndex);
    962        }
    963        catch (final SQLException e) {
    964            handleException(e);
    965            return null;
    966        }
    967    }
    968
    969    @Override
    970    public Reader getNCharacterStream(final String columnLabel) throws SQLException {
    971        try {
    972            return _res.getNCharacterStream(columnLabel);
    973        }
    974        catch (final SQLException e) {
    975            handleException(e);
    976            return null;
    977        }
    978    }
    979
    980    @Override
    981    public void updateNCharacterStream(final int columnIndex, final Reader reader, final long length) throws SQLException {
    982        try {
    983            _res.updateNCharacterStream(columnIndex, reader, length);
    984        }
    985        catch (final SQLException e) {
    986            handleException(e);
    987        }
    988    }
    989
    990    @Override
    991    public void updateNCharacterStream(final String columnLabel, final Reader reader, final long length) throws SQLException {
    992        try {
    993            _res.updateNCharacterStream(columnLabel, reader, length);
    994        }
    995        catch (final SQLException e) {
    996            handleException(e);
    997        }
    998    }
    999
    1000    @Override
    1001    public void updateAsciiStream(final int columnIndex, final InputStream inputStream, final long length) throws SQLException {
    1002        try {
    1003            _res.updateAsciiStream(columnIndex, inputStream, length);
    1004        }
    1005        catch (final SQLException e) {
    1006            handleException(e);
    1007        }
    1008    }
    1009
    1010    @Override
    1011    public void updateBinaryStream(final int columnIndex, final InputStream inputStream, final long length) throws SQLException {
    1012        try {
    1013            _res.updateBinaryStream(columnIndex, inputStream, length);
    1014        }
    1015        catch (final SQLException e) {
    1016            handleException(e);
    1017        }
    1018    }
    1019
    1020    @Override
    1021    public void updateCharacterStream(final int columnIndex, final Reader reader, final long length) throws SQLException {
    1022        try {
    1023            _res.updateCharacterStream(columnIndex, reader, length);
    1024        }
    1025        catch (final SQLException e) {
    1026            handleException(e);
    1027        }
    1028    }
    1029
    1030    @Override
    1031    public void updateAsciiStream(final String columnLabel, final InputStream inputStream, final long length) throws SQLException {
    1032        try {
    1033            _res.updateAsciiStream(columnLabel, inputStream, length);
    1034        }
    1035        catch (final SQLException e) {
    1036            handleException(e);
    1037        }
    1038    }
    1039
    1040    @Override
    1041    public void updateBinaryStream(final String columnLabel, final InputStream inputStream, final long length) throws SQLException {
    1042        try {
    1043            _res.updateBinaryStream(columnLabel, inputStream, length);
    1044        }
    1045        catch (final SQLException e) {
    1046            handleException(e);
    1047        }
    1048    }
    1049
    1050    @Override
    1051    public void updateCharacterStream(final String columnLabel, final Reader reader, final long length) throws SQLException {
    1052        try {
    1053            _res.updateCharacterStream(columnLabel, reader, length);
    1054        }
    1055        catch (final SQLException e) {
    1056            handleException(e);
    1057        }
    1058    }
    1059
    1060    @Override
    1061    public void updateBlob(final int columnIndex, final InputStream inputStream, final long length) throws SQLException {
    1062        try {
    1063            _res.updateBlob(columnIndex, inputStream, length);
    1064        }
    1065        catch (final SQLException e) {
    1066            handleException(e);
    1067        }
    1068    }
    1069
    1070    @Override
    1071    public void updateBlob(final String columnLabel, final InputStream inputStream, final long length) throws SQLException {
    1072        try {
    1073            _res.updateBlob(columnLabel, inputStream, length);
    1074        }
    1075        catch (final SQLException e) {
    1076            handleException(e);
    1077        }
    1078    }
    1079
    1080    @Override
    1081    public void updateClob(final int columnIndex, final Reader reader, final long length) throws SQLException {
    1082        try {
    1083            _res.updateClob(columnIndex, reader, length);
    1084        }
    1085        catch (final SQLException e) {
    1086            handleException(e);
    1087        }
    1088    }
    1089
    1090    @Override
    1091    public void updateClob(final String columnLabel, final Reader reader, final long length) throws SQLException {
    1092        try {
    1093            _res.updateClob(columnLabel, reader, length);
    1094        }
    1095        catch (final SQLException e) {
    1096            handleException(e);
    1097        }
    1098    }
    1099
    1100    @Override
    1101    public void updateNClob(final int columnIndex, final Reader reader, final long length) throws SQLException {
    1102        try {
    1103            _res.updateNClob(columnIndex, reader, length);
    1104        }
    1105        catch (final SQLException e) {
    1106            handleException(e);
    1107        }
    1108    }
    1109
    1110    @Override
    1111    public void updateNClob(final String columnLabel, final Reader reader, final long length) throws SQLException {
    1112        try {
    1113            _res.updateNClob(columnLabel, reader, length);
    1114        }
    1115        catch (final SQLException e) {
    1116            handleException(e);
    1117        }
    1118    }
    1119
    1120    @Override
    1121    public void updateNCharacterStream(final int columnIndex, final Reader reader) throws SQLException {
    1122        try {
    1123            _res.updateNCharacterStream(columnIndex, reader);
    1124        }
    1125        catch (final SQLException e) {
    1126            handleException(e);
    1127        }
    1128    }
    1129
    1130    @Override
    1131    public void updateNCharacterStream(final String columnLabel, final Reader reader) throws SQLException {
    1132        try {
    1133            _res.updateNCharacterStream(columnLabel, reader);
    1134        }
    1135        catch (final SQLException e) {
    1136            handleException(e);
    1137        }
    1138    }
    1139
    1140    @Override
    1141    public void updateAsciiStream(final int columnIndex, final InputStream inputStream) throws SQLException {
    1142        try {
    1143            _res.updateAsciiStream(columnIndex, inputStream);
    1144        }
    1145        catch (final SQLException e) {
    1146            handleException(e);
    1147        }
    1148    }
    1149
    1150    @Override
    1151    public void updateBinaryStream(final int columnIndex, final InputStream inputStream) throws SQLException {
    1152        try {
    1153            _res.updateBinaryStream(columnIndex, inputStream);
    1154        }
    1155        catch (final SQLException e) {
    1156            handleException(e);
    1157        }
    1158    }
    1159
    1160    @Override
    1161    public void updateCharacterStream(final int columnIndex, final Reader reader) throws SQLException {
    1162        try {
    1163            _res.updateCharacterStream(columnIndex, reader);
    1164        }
    1165        catch (final SQLException e) {
    1166            handleException(e);
    1167        }
    1168    }
    1169
    1170    @Override
    1171    public void updateAsciiStream(final String columnLabel, final InputStream inputStream) throws SQLException {
    1172        try {
    1173            _res.updateAsciiStream(columnLabel, inputStream);
    1174        }
    1175        catch (final SQLException e) {
    1176            handleException(e);
    1177        }
    1178    }
    1179
    1180    @Override
    1181    public void updateBinaryStream(final String columnLabel, final InputStream inputStream) throws SQLException {
    1182        try {
    1183            _res.updateBinaryStream(columnLabel, inputStream);
    1184        }
    1185        catch (final SQLException e) {
    1186            handleException(e);
    1187        }
    1188    }
    1189
    1190    @Override
    1191    public void updateCharacterStream(final String columnLabel, final Reader reader) throws SQLException {
    1192        try {
    1193            _res.updateCharacterStream(columnLabel, reader);
    1194        }
    1195        catch (final SQLException e) {
    1196            handleException(e);
    1197        }
    1198    }
    1199
    1200    @Override
    1201    public void updateBlob(final int columnIndex, final InputStream inputStream) throws SQLException {
    1202        try {
    1203            _res.updateBlob(columnIndex, inputStream);
    1204        }
    1205        catch (final SQLException e) {
    1206            handleException(e);
    1207        }
    1208    }
    1209
    1210    @Override
    1211    public void updateBlob(final String columnLabel, final InputStream inputStream) throws SQLException {
    1212        try {
    1213            _res.updateBlob(columnLabel, inputStream);
    1214        }
    1215        catch (final SQLException e) {
    1216            handleException(e);
    1217        }
    1218    }
    1219
    1220    @Override
    1221    public void updateClob(final int columnIndex, final Reader reader) throws SQLException {
    1222        try {
    1223            _res.updateClob(columnIndex, reader);
    1224        }
    1225        catch (final SQLException e) {
    1226            handleException(e);
    1227        }
    1228    }
    1229
    1230    @Override
    1231    public void updateClob(final String columnLabel, final Reader reader) throws SQLException {
    1232        try {
    1233            _res.updateClob(columnLabel, reader);
    1234        }
    1235        catch (final SQLException e) {
    1236            handleException(e);
    1237        }
    1238    }
    1239
    1240    @Override
    1241    public void updateNClob(final int columnIndex, final Reader reader) throws SQLException {
    1242        try {
    1243            _res.updateNClob(columnIndex, reader);
    1244        }
    1245        catch (final SQLException e) {
    1246            handleException(e);
    1247        }
    1248    }
    1249
    1250    @Override
    1251    public void updateNClob(final String columnLabel, final Reader reader) throws SQLException {
    1252        try {
    1253            _res.updateNClob(columnLabel, reader);
    1254        }
    1255        catch (final SQLException e) {
    1256            handleException(e);
    1257        }
    1258    }
    1259
    1260    @Override
    1261    public <T> T getObject(final int columnIndex, final Class<T> type) throws SQLException {
    1262        try {
    1263            return _res.getObject(columnIndex, type);
    1264        }
    1265        catch (final SQLException e) {
    1266            handleException(e);
    1267            return null;
    1268        }
    1269    }
    1270
    1271    @Override
    1272    public <T> T getObject(final String columnLabel, final Class<T> type)
    1273            throws SQLException {
    1274        try {
    1275            return _res.getObject(columnLabel, type);
    1276        }
    1277        catch (final SQLException e) {
    1278            handleException(e);
    1279            return null;
    1280        }
    1281    }
    1282
    1283    @Override
    1284    public String toString() {
    1285        return super.toString() + "[_res=" + _res + ", _stmt=" + _stmt + ", _conn=" + _conn + "]";
    1286    }
    1287}