    001/*
    002 * Licensed to the Apache Software Foundation (ASF) under one or more
    003 * contributor license agreements.  See the NOTICE file distributed with
    004 * this work for additional information regarding copyright ownership.
    005 * The ASF licenses this file to You under the Apache License, Version 2.0
    006 * (the "License"); you may not use this file except in compliance with
    007 * the License.  You may obtain a copy of the License at
    008 *
    009 *      http://www.apache.org/licenses/LICENSE-2.0
    010 *
    011 * Unless required by applicable law or agreed to in writing, software
    012 * distributed under the License is distributed on an "AS IS" BASIS,
    013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014 * See the License for the specific language governing permissions and
    015 * limitations under the License.
    016 */
    017package org.apache.commons.dbcp2;
    018
    019import java.io.InputStream;
    020import java.io.Reader;
    021import java.math.BigDecimal;
    022import java.net.URL;
    023import java.sql.Array;
    024import java.sql.Blob;
    025import java.sql.CallableStatement;
    026import java.sql.Clob;
    027import java.sql.Date;
    028import java.sql.NClob;
    029import java.sql.Ref;
    030import java.sql.RowId;
    031import java.sql.SQLException;
    032import java.sql.SQLType;
    033import java.sql.SQLXML;
    034import java.sql.Time;
    035import java.sql.Timestamp;
    036import java.util.Calendar;
    037import java.util.Map;
    038
    039/**
    040 * A base delegating implementation of {@link CallableStatement}.
    041 * <p>
    042 * All of the methods from the {@link CallableStatement} interface simply call the corresponding method on the
    043 * "delegate" provided in my constructor.
    044 * </p>
    045 * <p>
    046 * Extends AbandonedTrace to implement Statement tracking and logging of code which created the Statement. Tracking the
    047 * Statement ensures that the Connection which created it can close any open Statement's on Connection close.
    048 * </p>
    049 *
    050 * @since 2.0
    051 */
    052public class DelegatingCallableStatement extends DelegatingPreparedStatement implements CallableStatement {
    053
    054    /**
    055     * Creates a wrapper for the Statement which traces this Statement to the Connection which created it and the code
    056     * which created it.
    057     *
    058     * @param connection
    059     *            the {@link DelegatingConnection} that created this statement
    060     * @param statement
    061     *            the {@link CallableStatement} to delegate all calls to
    062     */
    063    public DelegatingCallableStatement(final DelegatingConnection<?> connection, final CallableStatement statement) {
    064        super(connection, statement);
    065    }
    066
    067    @Override
    068    public Array getArray(final int parameterIndex) throws SQLException {
    069        checkOpen();
    070        try {
    071            return getDelegateCallableStatement().getArray(parameterIndex);
    072        } catch (final SQLException e) {
    073            handleException(e);
    074            return null;
    075        }
    076    }
    077
    078    @Override
    079    public Array getArray(final String parameterName) throws SQLException {
    080        checkOpen();
    081        try {
    082            return getDelegateCallableStatement().getArray(parameterName);
    083        } catch (final SQLException e) {
    084            handleException(e);
    085            return null;
    086        }
    087    }
    088
    089    @Override
    090    public BigDecimal getBigDecimal(final int parameterIndex) throws SQLException {
    091        checkOpen();
    092        try {
    093            return getDelegateCallableStatement().getBigDecimal(parameterIndex);
    094        } catch (final SQLException e) {
    095            handleException(e);
    096            return null;
    097        }
    098    }
    099
    100    /** @deprecated Use {@link #getBigDecimal(int)} or {@link #getBigDecimal(String)} */
    101    @Override
    102    @Deprecated
    103    public BigDecimal getBigDecimal(final int parameterIndex, final int scale) throws SQLException {
    104        checkOpen();
    105        try {
    106            return getDelegateCallableStatement().getBigDecimal(parameterIndex, scale);
    107        } catch (final SQLException e) {
    108            handleException(e);
    109            return null;
    110        }
    111    }
    112
    113    @Override
    114    public BigDecimal getBigDecimal(final String parameterName) throws SQLException {
    115        checkOpen();
    116        try {
    117            return getDelegateCallableStatement().getBigDecimal(parameterName);
    118        } catch (final SQLException e) {
    119            handleException(e);
    120            return null;
    121        }
    122    }
    123
    124    @Override
    125    public Blob getBlob(final int parameterIndex) throws SQLException {
    126        checkOpen();
    127        try {
    128            return getDelegateCallableStatement().getBlob(parameterIndex);
    129        } catch (final SQLException e) {
    130            handleException(e);
    131            return null;
    132        }
    133    }
    134
    135    @Override
    136    public Blob getBlob(final String parameterName) throws SQLException {
    137        checkOpen();
    138        try {
    139            return getDelegateCallableStatement().getBlob(parameterName);
    140        } catch (final SQLException e) {
    141            handleException(e);
    142            return null;
    143        }
    144    }
    145
    146    @Override
    147    public boolean getBoolean(final int parameterIndex) throws SQLException {
    148        checkOpen();
    149        try {
    150            return getDelegateCallableStatement().getBoolean(parameterIndex);
    151        } catch (final SQLException e) {
    152            handleException(e);
    153            return false;
    154        }
    155    }
    156
    157    @Override
    158    public boolean getBoolean(final String parameterName) throws SQLException {
    159        checkOpen();
    160        try {
    161            return getDelegateCallableStatement().getBoolean(parameterName);
    162        } catch (final SQLException e) {
    163            handleException(e);
    164            return false;
    165        }
    166    }
    167
    168    @Override
    169    public byte getByte(final int parameterIndex) throws SQLException {
    170        checkOpen();
    171        try {
    172            return getDelegateCallableStatement().getByte(parameterIndex);
    173        } catch (final SQLException e) {
    174            handleException(e);
    175            return 0;
    176        }
    177    }
    178
    179    @Override
    180    public byte getByte(final String parameterName) throws SQLException {
    181        checkOpen();
    182        try {
    183            return getDelegateCallableStatement().getByte(parameterName);
    184        } catch (final SQLException e) {
    185            handleException(e);
    186            return 0;
    187        }
    188    }
    189
    190    @Override
    191    public byte[] getBytes(final int parameterIndex) throws SQLException {
    192        checkOpen();
    193        try {
    194            return getDelegateCallableStatement().getBytes(parameterIndex);
    195        } catch (final SQLException e) {
    196            handleException(e);
    197            return null;
    198        }
    199    }
    200
    201    @Override
    202    public byte[] getBytes(final String parameterName) throws SQLException {
    203        checkOpen();
    204        try {
    205            return getDelegateCallableStatement().getBytes(parameterName);
    206        } catch (final SQLException e) {
    207            handleException(e);
    208            return null;
    209        }
    210    }
    211
    212    @Override
    213    public Reader getCharacterStream(final int parameterIndex) throws SQLException {
    214        checkOpen();
    215        try {
    216            return getDelegateCallableStatement().getCharacterStream(parameterIndex);
    217        } catch (final SQLException e) {
    218            handleException(e);
    219            return null;
    220        }
    221    }
    222
    223    @Override
    224    public Reader getCharacterStream(final String parameterName) throws SQLException {
    225        checkOpen();
    226        try {
    227            return getDelegateCallableStatement().getCharacterStream(parameterName);
    228        } catch (final SQLException e) {
    229            handleException(e);
    230            return null;
    231        }
    232    }
    233
    234    @Override
    235    public Clob getClob(final int parameterIndex) throws SQLException {
    236        checkOpen();
    237        try {
    238            return getDelegateCallableStatement().getClob(parameterIndex);
    239        } catch (final SQLException e) {
    240            handleException(e);
    241            return null;
    242        }
    243    }
    244
    245    @Override
    246    public Clob getClob(final String parameterName) throws SQLException {
    247        checkOpen();
    248        try {
    249            return getDelegateCallableStatement().getClob(parameterName);
    250        } catch (final SQLException e) {
    251            handleException(e);
    252            return null;
    253        }
    254    }
    255
    256    @Override
    257    public Date getDate(final int parameterIndex) throws SQLException {
    258        checkOpen();
    259        try {
    260            return getDelegateCallableStatement().getDate(parameterIndex);
    261        } catch (final SQLException e) {
    262            handleException(e);
    263            return null;
    264        }
    265    }
    266
    267    @Override
    268    public Date getDate(final int parameterIndex, final Calendar cal) throws SQLException {
    269        checkOpen();
    270        try {
    271            return getDelegateCallableStatement().getDate(parameterIndex, cal);
    272        } catch (final SQLException e) {
    273            handleException(e);
    274            return null;
    275        }
    276    }
    277
    278    @Override
    279    public Date getDate(final String parameterName) throws SQLException {
    280        checkOpen();
    281        try {
    282            return getDelegateCallableStatement().getDate(parameterName);
    283        } catch (final SQLException e) {
    284            handleException(e);
    285            return null;
    286        }
    287    }
    288
    289    @Override
    290    public Date getDate(final String parameterName, final Calendar cal) throws SQLException {
    291        checkOpen();
    292        try {
    293            return getDelegateCallableStatement().getDate(parameterName, cal);
    294        } catch (final SQLException e) {
    295            handleException(e);
    296            return null;
    297        }
    298    }
    299
    300    private CallableStatement getDelegateCallableStatement() {
    301        return (CallableStatement) getDelegate();
    302    }
    303
    304    @Override
    305    public double getDouble(final int parameterIndex) throws SQLException {
    306        checkOpen();
    307        try {
    308            return getDelegateCallableStatement().getDouble(parameterIndex);
    309        } catch (final SQLException e) {
    310            handleException(e);
    311            return 0;
    312        }
    313    }
    314
    315    @Override
    316    public double getDouble(final String parameterName) throws SQLException {
    317        checkOpen();
    318        try {
    319            return getDelegateCallableStatement().getDouble(parameterName);
    320        } catch (final SQLException e) {
    321            handleException(e);
    322            return 0;
    323        }
    324    }
    325
    326    @Override
    327    public float getFloat(final int parameterIndex) throws SQLException {
    328        checkOpen();
    329        try {
    330            return getDelegateCallableStatement().getFloat(parameterIndex);
    331        } catch (final SQLException e) {
    332            handleException(e);
    333            return 0;
    334        }
    335    }
    336
    337    @Override
    338    public float getFloat(final String parameterName) throws SQLException {
    339        checkOpen();
    340        try {
    341            return getDelegateCallableStatement().getFloat(parameterName);
    342        } catch (final SQLException e) {
    343            handleException(e);
    344            return 0;
    345        }
    346    }
    347
    348    @Override
    349    public int getInt(final int parameterIndex) throws SQLException {
    350        checkOpen();
    351        try {
    352            return getDelegateCallableStatement().getInt(parameterIndex);
    353        } catch (final SQLException e) {
    354            handleException(e);
    355            return 0;
    356        }
    357    }
    358
    359    @Override
    360    public int getInt(final String parameterName) throws SQLException {
    361        checkOpen();
    362        try {
    363            return getDelegateCallableStatement().getInt(parameterName);
    364        } catch (final SQLException e) {
    365            handleException(e);
    366            return 0;
    367        }
    368    }
    369
    370    @Override
    371    public long getLong(final int parameterIndex) throws SQLException {
    372        checkOpen();
    373        try {
    374            return getDelegateCallableStatement().getLong(parameterIndex);
    375        } catch (final SQLException e) {
    376            handleException(e);
    377            return 0;
    378        }
    379    }
    380
    381    @Override
    382    public long getLong(final String parameterName) throws SQLException {
    383        checkOpen();
    384        try {
    385            return getDelegateCallableStatement().getLong(parameterName);
    386        } catch (final SQLException e) {
    387            handleException(e);
    388            return 0;
    389        }
    390    }
    391
    392    @Override
    393    public Reader getNCharacterStream(final int parameterIndex) throws SQLException {
    394        checkOpen();
    395        try {
    396            return getDelegateCallableStatement().getNCharacterStream(parameterIndex);
    397        } catch (final SQLException e) {
    398            handleException(e);
    399            return null;
    400        }
    401    }
    402
    403    @Override
    404    public Reader getNCharacterStream(final String parameterName) throws SQLException {
    405        checkOpen();
    406        try {
    407            return getDelegateCallableStatement().getNCharacterStream(parameterName);
    408        } catch (final SQLException e) {
    409            handleException(e);
    410            return null;
    411        }
    412    }
    413
    414    @Override
    415    public NClob getNClob(final int parameterIndex) throws SQLException {
    416        checkOpen();
    417        try {
    418            return getDelegateCallableStatement().getNClob(parameterIndex);
    419        } catch (final SQLException e) {
    420            handleException(e);
    421            return null;
    422        }
    423    }
    424
    425    @Override
    426    public NClob getNClob(final String parameterName) throws SQLException {
    427        checkOpen();
    428        try {
    429            return getDelegateCallableStatement().getNClob(parameterName);
    430        } catch (final SQLException e) {
    431            handleException(e);
    432            return null;
    433        }
    434    }
    435
    436    @Override
    437    public String getNString(final int parameterIndex) throws SQLException {
    438        checkOpen();
    439        try {
    440            return getDelegateCallableStatement().getNString(parameterIndex);
    441        } catch (final SQLException e) {
    442            handleException(e);
    443            return null;
    444        }
    445    }
    446
    447    @Override
    448    public String getNString(final String parameterName) throws SQLException {
    449        checkOpen();
    450        try {
    451            return getDelegateCallableStatement().getNString(parameterName);
    452        } catch (final SQLException e) {
    453            handleException(e);
    454            return null;
    455        }
    456    }
    457
    458    @Override
    459    public Object getObject(final int parameterIndex) throws SQLException {
    460        checkOpen();
    461        try {
    462            return getDelegateCallableStatement().getObject(parameterIndex);
    463        } catch (final SQLException e) {
    464            handleException(e);
    465            return null;
    466        }
    467    }
    468
    469    @Override
    470    public <T> T getObject(final int parameterIndex, final Class<T> type) throws SQLException {
    471        checkOpen();
    472        try {
    473            return getDelegateCallableStatement().getObject(parameterIndex, type);
    474        } catch (final SQLException e) {
    475            handleException(e);
    476            return null;
    477        }
    478    }
    479
    480    @Override
    481    public Object getObject(final int i, final Map<String, Class<?>> map) throws SQLException {
    482        checkOpen();
    483        try {
    484            return getDelegateCallableStatement().getObject(i, map);
    485        } catch (final SQLException e) {
    486            handleException(e);
    487            return null;
    488        }
    489    }
    490
    491    @Override
    492    public Object getObject(final String parameterName) throws SQLException {
    493        checkOpen();
    494        try {
    495            return getDelegateCallableStatement().getObject(parameterName);
    496        } catch (final SQLException e) {
    497            handleException(e);
    498            return null;
    499        }
    500    }
    501
    502    @Override
    503    public <T> T getObject(final String parameterName, final Class<T> type) throws SQLException {
    504        checkOpen();
    505        try {
    506            return getDelegateCallableStatement().getObject(parameterName, type);
    507        } catch (final SQLException e) {
    508            handleException(e);
    509            return null;
    510        }
    511    }
    512
    513    @Override
    514    public Object getObject(final String parameterName, final Map<String, Class<?>> map) throws SQLException {
    515        checkOpen();
    516        try {
    517            return getDelegateCallableStatement().getObject(parameterName, map);
    518        } catch (final SQLException e) {
    519            handleException(e);
    520            return null;
    521        }
    522    }
    523
    524    @Override
    525    public Ref getRef(final int parameterIndex) throws SQLException {
    526        checkOpen();
    527        try {
    528            return getDelegateCallableStatement().getRef(parameterIndex);
    529        } catch (final SQLException e) {
    530            handleException(e);
    531            return null;
    532        }
    533    }
    534
    535    @Override
    536    public Ref getRef(final String parameterName) throws SQLException {
    537        checkOpen();
    538        try {
    539            return getDelegateCallableStatement().getRef(parameterName);
    540        } catch (final SQLException e) {
    541            handleException(e);
    542            return null;
    543        }
    544    }
    545
    546    @Override
    547    public RowId getRowId(final int parameterIndex) throws SQLException {
    548        checkOpen();
    549        try {
    550            return getDelegateCallableStatement().getRowId(parameterIndex);
    551        } catch (final SQLException e) {
    552            handleException(e);
    553            return null;
    554        }
    555    }
    556
    557    @Override
    558    public RowId getRowId(final String parameterName) throws SQLException {
    559        checkOpen();
    560        try {
    561            return getDelegateCallableStatement().getRowId(parameterName);
    562        } catch (final SQLException e) {
    563            handleException(e);
    564            return null;
    565        }
    566    }
    567
    568    @Override
    569    public short getShort(final int parameterIndex) throws SQLException {
    570        checkOpen();
    571        try {
    572            return getDelegateCallableStatement().getShort(parameterIndex);
    573        } catch (final SQLException e) {
    574            handleException(e);
    575            return 0;
    576        }
    577    }
    578
    579    @Override
    580    public short getShort(final String parameterName) throws SQLException {
    581        checkOpen();
    582        try {
    583            return getDelegateCallableStatement().getShort(parameterName);
    584        } catch (final SQLException e) {
    585            handleException(e);
    586            return 0;
    587        }
    588    }
    589
    590    @Override
    591    public SQLXML getSQLXML(final int parameterIndex) throws SQLException {
    592        checkOpen();
    593        try {
    594            return getDelegateCallableStatement().getSQLXML(parameterIndex);
    595        } catch (final SQLException e) {
    596            handleException(e);
    597            return null;
    598        }
    599    }
    600
    601    @Override
    602    public SQLXML getSQLXML(final String parameterName) throws SQLException {
    603        checkOpen();
    604        try {
    605            return getDelegateCallableStatement().getSQLXML(parameterName);
    606        } catch (final SQLException e) {
    607            handleException(e);
    608            return null;
    609        }
    610    }
    611
    612    @Override
    613    public String getString(final int parameterIndex) throws SQLException {
    614        checkOpen();
    615        try {
    616            return getDelegateCallableStatement().getString(parameterIndex);
    617        } catch (final SQLException e) {
    618            handleException(e);
    619            return null;
    620        }
    621    }
    622
    623    @Override
    624    public String getString(final String parameterName) throws SQLException {
    625        checkOpen();
    626        try {
    627            return getDelegateCallableStatement().getString(parameterName);
    628        } catch (final SQLException e) {
    629            handleException(e);
    630            return null;
    631        }
    632    }
    633
    634    @Override
    635    public Time getTime(final int parameterIndex) throws SQLException {
    636        checkOpen();
    637        try {
    638            return getDelegateCallableStatement().getTime(parameterIndex);
    639        } catch (final SQLException e) {
    640            handleException(e);
    641            return null;
    642        }
    643    }
    644
    645    @Override
    646    public Time getTime(final int parameterIndex, final Calendar cal) throws SQLException {
    647        checkOpen();
    648        try {
    649            return getDelegateCallableStatement().getTime(parameterIndex, cal);
    650        } catch (final SQLException e) {
    651            handleException(e);
    652            return null;
    653        }
    654    }
    655
    656    @Override
    657    public Time getTime(final String parameterName) throws SQLException {
    658        checkOpen();
    659        try {
    660            return getDelegateCallableStatement().getTime(parameterName);
    661        } catch (final SQLException e) {
    662            handleException(e);
    663            return null;
    664        }
    665    }
    666
    667    @Override
    668    public Time getTime(final String parameterName, final Calendar cal) throws SQLException {
    669        checkOpen();
    670        try {
    671            return getDelegateCallableStatement().getTime(parameterName, cal);
    672        } catch (final SQLException e) {
    673            handleException(e);
    674            return null;
    675        }
    676    }
    677
    678    @Override
    679    public Timestamp getTimestamp(final int parameterIndex) throws SQLException {
    680        checkOpen();
    681        try {
    682            return getDelegateCallableStatement().getTimestamp(parameterIndex);
    683        } catch (final SQLException e) {
    684            handleException(e);
    685            return null;
    686        }
    687    }
    688
    689    @Override
    690    public Timestamp getTimestamp(final int parameterIndex, final Calendar cal) throws SQLException {
    691        checkOpen();
    692        try {
    693            return getDelegateCallableStatement().getTimestamp(parameterIndex, cal);
    694        } catch (final SQLException e) {
    695            handleException(e);
    696            return null;
    697        }
    698    }
    699
    700    @Override
    701    public Timestamp getTimestamp(final String parameterName) throws SQLException {
    702        checkOpen();
    703        try {
    704            return getDelegateCallableStatement().getTimestamp(parameterName);
    705        } catch (final SQLException e) {
    706            handleException(e);
    707            return null;
    708        }
    709    }
    710
    711    @Override
    712    public Timestamp getTimestamp(final String parameterName, final Calendar cal) throws SQLException {
    713        checkOpen();
    714        try {
    715            return getDelegateCallableStatement().getTimestamp(parameterName, cal);
    716        } catch (final SQLException e) {
    717            handleException(e);
    718            return null;
    719        }
    720    }
    721
    722    @Override
    723    public URL getURL(final int parameterIndex) throws SQLException {
    724        checkOpen();
    725        try {
    726            return getDelegateCallableStatement().getURL(parameterIndex);
    727        } catch (final SQLException e) {
    728            handleException(e);
    729            return null;
    730        }
    731    }
    732
    733    @Override
    734    public URL getURL(final String parameterName) throws SQLException {
    735        checkOpen();
    736        try {
    737            return getDelegateCallableStatement().getURL(parameterName);
    738        } catch (final SQLException e) {
    739            handleException(e);
    740            return null;
    741        }
    742    }
    743
    744    @Override
    745    public void registerOutParameter(final int parameterIndex, final int sqlType) throws SQLException {
    746        checkOpen();
    747        try {
    748            getDelegateCallableStatement().registerOutParameter(parameterIndex, sqlType);
    749        } catch (final SQLException e) {
    750            handleException(e);
    751        }
    752    }
    753
    754    @Override
    755    public void registerOutParameter(final int parameterIndex, final int sqlType, final int scale) throws SQLException {
    756        checkOpen();
    757        try {
    758            getDelegateCallableStatement().registerOutParameter(parameterIndex, sqlType, scale);
    759        } catch (final SQLException e) {
    760            handleException(e);
    761        }
    762    }
    763
    764    @Override
    765    public void registerOutParameter(final int paramIndex, final int sqlType, final String typeName)
    766            throws SQLException {
    767        checkOpen();
    768        try {
    769            getDelegateCallableStatement().registerOutParameter(paramIndex, sqlType, typeName);
    770        } catch (final SQLException e) {
    771            handleException(e);
    772        }
    773    }
    774
    775    /**
    776     * @since 2.5.0
    777     */
    778    @Override
    779    public void registerOutParameter(final int parameterIndex, final SQLType sqlType) throws SQLException {
    780        checkOpen();
    781        try {
    782            getDelegateCallableStatement().registerOutParameter(parameterIndex, sqlType);
    783        } catch (final SQLException e) {
    784            handleException(e);
    785        }
    786    }
    787
    788    /**
    789     * @since 2.5.0
    790     */
    791    @Override
    792    public void registerOutParameter(final int parameterIndex, final SQLType sqlType, final int scale)
    793            throws SQLException {
    794        checkOpen();
    795        try {
    796            getDelegateCallableStatement().registerOutParameter(parameterIndex, sqlType, scale);
    797        } catch (final SQLException e) {
    798            handleException(e);
    799        }
    800    }
    801
    802    /**
    803     * @since 2.5.0
    804     */
    805    @Override
    806    public void registerOutParameter(final int parameterIndex, final SQLType sqlType, final String typeName)
    807            throws SQLException {
    808        checkOpen();
    809        try {
    810            getDelegateCallableStatement().registerOutParameter(parameterIndex, sqlType, typeName);
    811        } catch (final SQLException e) {
    812            handleException(e);
    813        }
    814    }
    815
    816    @Override
    817    public void registerOutParameter(final String parameterName, final int sqlType) throws SQLException {
    818        checkOpen();
    819        try {
    820            getDelegateCallableStatement().registerOutParameter(parameterName, sqlType);
    821        } catch (final SQLException e) {
    822            handleException(e);
    823        }
    824    }
    825
    826    @Override
    827    public void registerOutParameter(final String parameterName, final int sqlType, final int scale)
    828            throws SQLException {
    829        checkOpen();
    830        try {
    831            getDelegateCallableStatement().registerOutParameter(parameterName, sqlType, scale);
    832        } catch (final SQLException e) {
    833            handleException(e);
    834        }
    835    }
    836
    837    @Override
    838    public void registerOutParameter(final String parameterName, final int sqlType, final String typeName)
    839            throws SQLException {
    840        checkOpen();
    841        try {
    842            getDelegateCallableStatement().registerOutParameter(parameterName, sqlType, typeName);
    843        } catch (final SQLException e) {
    844            handleException(e);
    845        }
    846    }
    847
    848    /**
    849     * @since 2.5.0
    850     */
    851    @Override
    852    public void registerOutParameter(final String parameterName, final SQLType sqlType) throws SQLException {
    853        checkOpen();
    854        try {
    855            getDelegateCallableStatement().registerOutParameter(parameterName, sqlType);
    856        } catch (final SQLException e) {
    857            handleException(e);
    858        }
    859    }
    860
    861    /**
    862     * @since 2.5.0
    863     */
    864    @Override
    865    public void registerOutParameter(final String parameterName, final SQLType sqlType, final int scale)
    866            throws SQLException {
    867        checkOpen();
    868        try {
    869            getDelegateCallableStatement().registerOutParameter(parameterName, sqlType, scale);
    870        } catch (final SQLException e) {
    871            handleException(e);
    872        }
    873    }
    874
    875    /**
    876     * @since 2.5.0
    877     */
    878    @Override
    879    public void registerOutParameter(final String parameterName, final SQLType sqlType, final String typeName)
    880            throws SQLException {
    881        checkOpen();
    882        try {
    883            getDelegateCallableStatement().registerOutParameter(parameterName, sqlType, typeName);
    884        } catch (final SQLException e) {
    885            handleException(e);
    886        }
    887    }
    888
    889    @Override
    890    public void setAsciiStream(final String parameterName, final InputStream inputStream) throws SQLException {
    891        checkOpen();
    892        try {
    893            getDelegateCallableStatement().setAsciiStream(parameterName, inputStream);
    894        } catch (final SQLException e) {
    895            handleException(e);
    896        }
    897    }
    898
    899    @Override
    900    public void setAsciiStream(final String parameterName, final InputStream x, final int length) throws SQLException {
    901        checkOpen();
    902        try {
    903            getDelegateCallableStatement().setAsciiStream(parameterName, x, length);
    904        } catch (final SQLException e) {
    905            handleException(e);
    906        }
    907    }
    908
    909    @Override
    910    public void setAsciiStream(final String parameterName, final InputStream inputStream, final long length)
    911            throws SQLException {
    912        checkOpen();
    913        try {
    914            getDelegateCallableStatement().setAsciiStream(parameterName, inputStream, length);
    915        } catch (final SQLException e) {
    916            handleException(e);
    917        }
    918    }
    919
    920    @Override
    921    public void setBigDecimal(final String parameterName, final BigDecimal x) throws SQLException {
    922        checkOpen();
    923        try {
    924            getDelegateCallableStatement().setBigDecimal(parameterName, x);
    925        } catch (final SQLException e) {
    926            handleException(e);
    927        }
    928    }
    929
    930    @Override
    931    public void setBinaryStream(final String parameterName, final InputStream inputStream) throws SQLException {
    932        checkOpen();
    933        try {
    934            getDelegateCallableStatement().setBinaryStream(parameterName, inputStream);
    935        } catch (final SQLException e) {
    936            handleException(e);
    937        }
    938    }
    939
    940    @Override
    941    public void setBinaryStream(final String parameterName, final InputStream x, final int length) throws SQLException {
    942        checkOpen();
    943        try {
    944            getDelegateCallableStatement().setBinaryStream(parameterName, x, length);
    945        } catch (final SQLException e) {
    946            handleException(e);
    947        }
    948    }
    949
    950    @Override
    951    public void setBinaryStream(final String parameterName, final InputStream inputStream, final long length)
    952            throws SQLException {
    953        checkOpen();
    954        try {
    955            getDelegateCallableStatement().setBinaryStream(parameterName, inputStream, length);
    956        } catch (final SQLException e) {
    957            handleException(e);
    958        }
    959    }
    960
    961    @Override
    962    public void setBlob(final String parameterName, final Blob blob) throws SQLException {
    963        checkOpen();
    964        try {
    965            getDelegateCallableStatement().setBlob(parameterName, blob);
    966        } catch (final SQLException e) {
    967            handleException(e);
    968        }
    969    }
    970
    971    @Override
    972    public void setBlob(final String parameterName, final InputStream inputStream) throws SQLException {
    973        checkOpen();
    974        try {
    975            getDelegateCallableStatement().setBlob(parameterName, inputStream);
    976        } catch (final SQLException e) {
    977            handleException(e);
    978        }
    979    }
    980
    981    @Override
    982    public void setBlob(final String parameterName, final InputStream inputStream, final long length)
    983            throws SQLException {
    984        checkOpen();
    985        try {
    986            getDelegateCallableStatement().setBlob(parameterName, inputStream, length);
    987        } catch (final SQLException e) {
    988            handleException(e);
    989        }
    990    }
    991
    992    @Override
    993    public void setBoolean(final String parameterName, final boolean x) throws SQLException {
    994        checkOpen();
    995        try {
    996            getDelegateCallableStatement().setBoolean(parameterName, x);
    997        } catch (final SQLException e) {
    998            handleException(e);
    999        }
    1000    }
    1001
    1002    @Override
    1003    public void setByte(final String parameterName, final byte x) throws SQLException {
    1004        checkOpen();
    1005        try {
    1006            getDelegateCallableStatement().setByte(parameterName, x);
    1007        } catch (final SQLException e) {
    1008            handleException(e);
    1009        }
    1010    }
    1011
    1012    @Override
    1013    public void setBytes(final String parameterName, final byte[] x) throws SQLException {
    1014        checkOpen();
    1015        try {
    1016            getDelegateCallableStatement().setBytes(parameterName, x);
    1017        } catch (final SQLException e) {
    1018            handleException(e);
    1019        }
    1020    }
    1021
    1022    @Override
    1023    public void setCharacterStream(final String parameterName, final Reader reader) throws SQLException {
    1024        checkOpen();
    1025        try {
    1026            getDelegateCallableStatement().setCharacterStream(parameterName, reader);
    1027        } catch (final SQLException e) {
    1028            handleException(e);
    1029        }
    1030    }
    1031
    1032    @Override
    1033    public void setCharacterStream(final String parameterName, final Reader reader, final int length)
    1034            throws SQLException {
    1035        checkOpen();
    1036        getDelegateCallableStatement().setCharacterStream(parameterName, reader, length);
    1037    }
    1038
    1039    @Override
    1040    public void setCharacterStream(final String parameterName, final Reader reader, final long length)
    1041            throws SQLException {
    1042        checkOpen();
    1043        try {
    1044            getDelegateCallableStatement().setCharacterStream(parameterName, reader, length);
    1045        } catch (final SQLException e) {
    1046            handleException(e);
    1047        }
    1048    }
    1049
    1050    @Override
    1051    public void setClob(final String parameterName, final Clob clob) throws SQLException {
    1052        checkOpen();
    1053        try {
    1054            getDelegateCallableStatement().setClob(parameterName, clob);
    1055        } catch (final SQLException e) {
    1056            handleException(e);
    1057        }
    1058    }
    1059
    1060    @Override
    1061    public void setClob(final String parameterName, final Reader reader) throws SQLException {
    1062        checkOpen();
    1063        try {
    1064            getDelegateCallableStatement().setClob(parameterName, reader);
    1065        } catch (final SQLException e) {
    1066            handleException(e);
    1067        }
    1068    }
    1069
    1070    @Override
    1071    public void setClob(final String parameterName, final Reader reader, final long length) throws SQLException {
    1072        checkOpen();
    1073        try {
    1074            getDelegateCallableStatement().setClob(parameterName, reader, length);
    1075        } catch (final SQLException e) {
    1076            handleException(e);
    1077        }
    1078    }
    1079
    1080    @Override
    1081    public void setDate(final String parameterName, final Date x) throws SQLException {
    1082        checkOpen();
    1083        try {
    1084            getDelegateCallableStatement().setDate(parameterName, x);
    1085        } catch (final SQLException e) {
    1086            handleException(e);
    1087        }
    1088    }
    1089
    1090    @Override
    1091    public void setDate(final String parameterName, final Date x, final Calendar cal) throws SQLException {
    1092        checkOpen();
    1093        try {
    1094            getDelegateCallableStatement().setDate(parameterName, x, cal);
    1095        } catch (final SQLException e) {
    1096            handleException(e);
    1097        }
    1098    }
    1099
    1100    @Override
    1101    public void setDouble(final String parameterName, final double x) throws SQLException {
    1102        checkOpen();
    1103        try {
    1104            getDelegateCallableStatement().setDouble(parameterName, x);
    1105        } catch (final SQLException e) {
    1106            handleException(e);
    1107        }
    1108    }
    1109
    1110    @Override
    1111    public void setFloat(final String parameterName, final float x) throws SQLException {
    1112        checkOpen();
    1113        try {
    1114            getDelegateCallableStatement().setFloat(parameterName, x);
    1115        } catch (final SQLException e) {
    1116            handleException(e);
    1117        }
    1118    }
    1119
    1120    @Override
    1121    public void setInt(final String parameterName, final int x) throws SQLException {
    1122        checkOpen();
    1123        try {
    1124            getDelegateCallableStatement().setInt(parameterName, x);
    1125        } catch (final SQLException e) {
    1126            handleException(e);
    1127        }
    1128    }
    1129
    1130    @Override
    1131    public void setLong(final String parameterName, final long x) throws SQLException {
    1132        checkOpen();
    1133        try {
    1134            getDelegateCallableStatement().setLong(parameterName, x);
    1135        } catch (final SQLException e) {
    1136            handleException(e);
    1137        }
    1138    }
    1139
    1140    @Override
    1141    public void setNCharacterStream(final String parameterName, final Reader reader) throws SQLException {
    1142        checkOpen();
    1143        try {
    1144            getDelegateCallableStatement().setNCharacterStream(parameterName, reader);
    1145        } catch (final SQLException e) {
    1146            handleException(e);
    1147        }
    1148    }
    1149
    1150    @Override
    1151    public void setNCharacterStream(final String parameterName, final Reader reader, final long length)
    1152            throws SQLException {
    1153        checkOpen();
    1154        try {
    1155            getDelegateCallableStatement().setNCharacterStream(parameterName, reader, length);
    1156        } catch (final SQLException e) {
    1157            handleException(e);
    1158        }
    1159    }
    1160
    1161    @Override
    1162    public void setNClob(final String parameterName, final NClob value) throws SQLException {
    1163        checkOpen();
    1164        try {
    1165            getDelegateCallableStatement().setNClob(parameterName, value);
    1166        } catch (final SQLException e) {
    1167            handleException(e);
    1168        }
    1169    }
    1170
    1171    @Override
    1172    public void setNClob(final String parameterName, final Reader reader) throws SQLException {
    1173        checkOpen();
    1174        try {
    1175            getDelegateCallableStatement().setNClob(parameterName, reader);
    1176        } catch (final SQLException e) {
    1177            handleException(e);
    1178        }
    1179    }
    1180
    1181    @Override
    1182    public void setNClob(final String parameterName, final Reader reader, final long length) throws SQLException {
    1183        checkOpen();
    1184        try {
    1185            getDelegateCallableStatement().setNClob(parameterName, reader, length);
    1186        } catch (final SQLException e) {
    1187            handleException(e);
    1188        }
    1189    }
    1190
    1191    @Override
    1192    public void setNString(final String parameterName, final String value) throws SQLException {
    1193        checkOpen();
    1194        try {
    1195            getDelegateCallableStatement().setNString(parameterName, value);
    1196        } catch (final SQLException e) {
    1197            handleException(e);
    1198        }
    1199    }
    1200
    1201    @Override
    1202    public void setNull(final String parameterName, final int sqlType) throws SQLException {
    1203        checkOpen();
    1204        try {
    1205            getDelegateCallableStatement().setNull(parameterName, sqlType);
    1206        } catch (final SQLException e) {
    1207            handleException(e);
    1208        }
    1209    }
    1210
    1211    @Override
    1212    public void setNull(final String parameterName, final int sqlType, final String typeName) throws SQLException {
    1213        checkOpen();
    1214        try {
    1215            getDelegateCallableStatement().setNull(parameterName, sqlType, typeName);
    1216        } catch (final SQLException e) {
    1217            handleException(e);
    1218        }
    1219    }
    1220
    1221    @Override
    1222    public void setObject(final String parameterName, final Object x) throws SQLException {
    1223        checkOpen();
    1224        try {
    1225            getDelegateCallableStatement().setObject(parameterName, x);
    1226        } catch (final SQLException e) {
    1227            handleException(e);
    1228        }
    1229    }
    1230
    1231    @Override
    1232    public void setObject(final String parameterName, final Object x, final int targetSqlType) throws SQLException {
    1233        checkOpen();
    1234        try {
    1235            getDelegateCallableStatement().setObject(parameterName, x, targetSqlType);
    1236        } catch (final SQLException e) {
    1237            handleException(e);
    1238        }
    1239    }
    1240
    1241    @Override
    1242    public void setObject(final String parameterName, final Object x, final int targetSqlType, final int scale)
    1243            throws SQLException {
    1244        checkOpen();
    1245        try {
    1246            getDelegateCallableStatement().setObject(parameterName, x, targetSqlType, scale);
    1247        } catch (final SQLException e) {
    1248            handleException(e);
    1249        }
    1250    }
    1251
    1252    /**
    1253     * @since 2.5.0
    1254     */
    1255    @Override
    1256    public void setObject(final String parameterName, final Object x, final SQLType targetSqlType) throws SQLException {
    1257        checkOpen();
    1258        try {
    1259            getDelegateCallableStatement().setObject(parameterName, x, targetSqlType);
    1260        } catch (final SQLException e) {
    1261            handleException(e);
    1262        }
    1263    }
    1264
    1265    /**
    1266     * @since 2.5.0
    1267     */
    1268    @Override
    1269    public void setObject(final String parameterName, final Object x, final SQLType targetSqlType,
    1270            final int scaleOrLength) throws SQLException {
    1271        checkOpen();
    1272        try {
    1273            getDelegateCallableStatement().setObject(parameterName, x, targetSqlType, scaleOrLength);
    1274        } catch (final SQLException e) {
    1275            handleException(e);
    1276        }
    1277    }
    1278
    1279    @Override
    1280    public void setRowId(final String parameterName, final RowId value) throws SQLException {
    1281        checkOpen();
    1282        try {
    1283            getDelegateCallableStatement().setRowId(parameterName, value);
    1284        } catch (final SQLException e) {
    1285            handleException(e);
    1286        }
    1287    }
    1288
    1289    @Override
    1290    public void setShort(final String parameterName, final short x) throws SQLException {
    1291        checkOpen();
    1292        try {
    1293            getDelegateCallableStatement().setShort(parameterName, x);
    1294        } catch (final SQLException e) {
    1295            handleException(e);
    1296        }
    1297    }
    1298
    1299    @Override
    1300    public void setSQLXML(final String parameterName, final SQLXML value) throws SQLException {
    1301        checkOpen();
    1302        try {
    1303            getDelegateCallableStatement().setSQLXML(parameterName, value);
    1304        } catch (final SQLException e) {
    1305            handleException(e);
    1306        }
    1307    }
    1308
    1309    @Override
    1310    public void setString(final String parameterName, final String x) throws SQLException {
    1311        checkOpen();
    1312        try {
    1313            getDelegateCallableStatement().setString(parameterName, x);
    1314        } catch (final SQLException e) {
    1315            handleException(e);
    1316        }
    1317    }
    1318
    1319    @Override
    1320    public void setTime(final String parameterName, final Time x) throws SQLException {
    1321        checkOpen();
    1322        try {
    1323            getDelegateCallableStatement().setTime(parameterName, x);
    1324        } catch (final SQLException e) {
    1325            handleException(e);
    1326        }
    1327    }
    1328
    1329    @Override
    1330    public void setTime(final String parameterName, final Time x, final Calendar cal) throws SQLException {
    1331        checkOpen();
    1332        try {
    1333            getDelegateCallableStatement().setTime(parameterName, x, cal);
    1334        } catch (final SQLException e) {
    1335            handleException(e);
    1336        }
    1337    }
    1338
    1339    @Override
    1340    public void setTimestamp(final String parameterName, final Timestamp x) throws SQLException {
    1341        checkOpen();
    1342        try {
    1343            getDelegateCallableStatement().setTimestamp(parameterName, x);
    1344        } catch (final SQLException e) {
    1345            handleException(e);
    1346        }
    1347    }
    1348
    1349    @Override
    1350    public void setTimestamp(final String parameterName, final Timestamp x, final Calendar cal) throws SQLException {
    1351        checkOpen();
    1352        try {
    1353            getDelegateCallableStatement().setTimestamp(parameterName, x, cal);
    1354        } catch (final SQLException e) {
    1355            handleException(e);
    1356        }
    1357    }
    1358
    1359    @Override
    1360    public void setURL(final String parameterName, final URL val) throws SQLException {
    1361        checkOpen();
    1362        try {
    1363            getDelegateCallableStatement().setURL(parameterName, val);
    1364        } catch (final SQLException e) {
    1365            handleException(e);
    1366        }
    1367    }
    1368
    1369    @Override
    1370    public boolean wasNull() throws SQLException {
    1371        checkOpen();
    1372        try {
    1373            return getDelegateCallableStatement().wasNull();
    1374        } catch (final SQLException e) {
    1375            handleException(e);
    1376            return false;
    1377        }
    1378    }
    1379
    1380}