    001    /**
    002     * Copyright 2007-2008 Arthur Blake
    003     *
    004     * Licensed under the Apache License, Version 2.0 (the "License");
    005     * you may not use this file except in compliance with the License.
    006     * You may obtain a copy of the License at
    007     *
    008     *    http://www.apache.org/licenses/LICENSE-2.0
    009     *
    010     * Unless required by applicable law or agreed to in writing, software
    011     * distributed under the License is distributed on an "AS IS" BASIS,
    012     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    013     * See the License for the specific language governing permissions and
    014     * limitations under the License.
    015     *
    016     */
    017    package net.sf.log4jdbc;
    018
    019    import java.io.InputStream;
    020    import java.io.Reader;
    021    import java.math.BigDecimal;
    022    import java.net.URL;
    023    import java.sql.*;
    024    import java.util.Calendar;
    025    import java.util.Map;
    026
    027    /**
    028     * Wraps a CallableStatement and reports method calls, returns and exceptions.
    029     *
    030     * @author Arthur Blake
    031     */
    032    public class CallableStatementSpy extends PreparedStatementSpy implements CallableStatement
    033    {
    034      private final SpyLogDelegator log;
    035
    036      protected void reportAllReturns(String methodCall, String msg)
    037      {
    038        log.methodReturned(this, methodCall, msg);
    039      }
    040
    041      /**
    042       * The real underlying CallableStatement that this CallableStatementSpy wraps.
    043       */
    044      private CallableStatement realCallableStatement;
    045
    046      /**
    047       * Create a CallableStatementSpy (JDBC 4.0 version) to spy upon a CallableStatement.
    048       *
    049       * @param sql                   The SQL used for this CallableStatement
    050       * @param connectionSpy         The ConnectionSpy which produced this CallableStatementSpy
    051       * @param realCallableStatement The real CallableStatement that is being spied upon
    052       */
    053      public CallableStatementSpy(String sql, ConnectionSpy connectionSpy, CallableStatement realCallableStatement)
    054      {
    055        super(sql, connectionSpy, realCallableStatement);
    056        this.realCallableStatement = realCallableStatement;
    057        log = SpyLogFactory.getSpyLogDelegator();
    058      }
    059
    060      public String getClassType()
    061      {
    062        return "CallableStatement";
    063      }
    064
    065      // forwarding methods
    066
    067      public Date getDate(int parameterIndex) throws SQLException
    068      {
    069        String methodCall = "getDate(" + parameterIndex + ")";
    070        try
    071        {
    072          return (Date) reportReturn(methodCall, realCallableStatement.getDate(parameterIndex));
    073        }
    074        catch (SQLException s)
    075        {
    076          reportException(methodCall, s);
    077          throw s;
    078        }
    079      }
    080
    081      public Date getDate(int parameterIndex, Calendar cal) throws SQLException
    082      {
    083        String methodCall = "getDate(" + parameterIndex + ", " + cal + ")";
    084        try
    085        {
    086          return (Date) reportReturn(methodCall, realCallableStatement.getDate(parameterIndex, cal));
    087        }
    088        catch (SQLException s)
    089        {
    090          reportException(methodCall, s);
    091          throw s;
    092        }
    093      }
    094
    095      public Ref getRef(String parameterName) throws SQLException
    096      {
    097        String methodCall = "getRef(" + parameterName + ")";
    098        try
    099        {
    100          return (Ref) reportReturn(methodCall, realCallableStatement.getRef(parameterName));
    101        }
    102        catch (SQLException s)
    103        {
    104          reportException(methodCall, s);
    105          throw s;
    106        }
    107      }
    108
    109      public Time getTime(String parameterName) throws SQLException
    110      {
    111        String methodCall = "getTime(" + parameterName + ")";
    112        try
    113        {
    114          return (Time) reportReturn(methodCall, realCallableStatement.getTime(parameterName));
    115        }
    116        catch (SQLException s)
    117        {
    118          reportException(methodCall, s);
    119          throw s;
    120        }
    121      }
    122
    123      public void setTime(String parameterName, Time x) throws SQLException
    124      {
    125        String methodCall = "setTime(" + parameterName + ", " + x + ")";
    126        try
    127        {
    128          realCallableStatement.setTime(parameterName, x);
    129        }
    130        catch (SQLException s)
    131        {
    132          reportException(methodCall, s);
    133          throw s;
    134        }
    135        reportReturn(methodCall);
    136      }
    137
    138      public Blob getBlob(int i) throws SQLException
    139      {
    140        String methodCall = "getBlob(" + i + ")";
    141        try
    142        {
    143          return (Blob) reportReturn(methodCall, realCallableStatement.getBlob(i));
    144        }
    145        catch (SQLException s)
    146        {
    147          reportException(methodCall, s);
    148          throw s;
    149        }
    150      }
    151
    152      public Clob getClob(int i) throws SQLException
    153      {
    154        String methodCall = "getClob(" + i + ")";
    155        try
    156        {
    157          return (Clob) reportReturn(methodCall, realCallableStatement.getClob(i));
    158        }
    159        catch (SQLException s)
    160        {
    161          reportException(methodCall, s);
    162          throw s;
    163        }
    164      }
    165
    166      public Array getArray(int i) throws SQLException
    167      {
    168        String methodCall = "getArray(" + i + ")";
    169        try
    170        {
    171          return (Array) reportReturn(methodCall, realCallableStatement.getArray(i));
    172        }
    173        catch (SQLException s)
    174        {
    175          reportException(methodCall, s);
    176          throw s;
    177        }
    178      }
    179
    180      public byte[] getBytes(int parameterIndex) throws SQLException
    181      {
    182        String methodCall = "getBytes(" + parameterIndex + ")";
    183        try
    184        {
    185          return (byte[]) reportReturn(methodCall, realCallableStatement.getBytes(parameterIndex));
    186        }
    187        catch (SQLException s)
    188        {
    189          reportException(methodCall, s);
    190          throw s;
    191        }
    192      }
    193
    194      public double getDouble(int parameterIndex) throws SQLException
    195      {
    196        String methodCall = "getDouble(" + parameterIndex + ")";
    197        try
    198        {
    199          return reportReturn(methodCall, realCallableStatement.getDouble(parameterIndex));
    200        }
    201        catch (SQLException s)
    202        {
    203          reportException(methodCall, s);
    204          throw s;
    205        }
    206      }
    207
    208      public int getInt(int parameterIndex) throws SQLException
    209      {
    210        String methodCall = "getInt(" + parameterIndex + ")";
    211        try
    212        {
    213          return reportReturn(methodCall, realCallableStatement.getInt(parameterIndex));
    214        }
    215        catch (SQLException s)
    216        {
    217          reportException(methodCall, s);
    218          throw s;
    219        }
    220      }
    221
    222      public boolean wasNull() throws SQLException
    223      {
    224        String methodCall = "wasNull()";
    225        try
    226        {
    227          return reportReturn(methodCall, realCallableStatement.wasNull());
    228        }
    229        catch (SQLException s)
    230        {
    231          reportException(methodCall, s);
    232          throw s;
    233        }
    234      }
    235
    236      public Time getTime(int parameterIndex) throws SQLException
    237      {
    238        String methodCall = "getTime(" + parameterIndex + ")";
    239        try
    240        {
    241          return (Time) reportReturn(methodCall, realCallableStatement.getTime(parameterIndex));
    242        }
    243        catch (SQLException s)
    244        {
    245          reportException(methodCall, s);
    246          throw s;
    247        }
    248      }
    249
    250      public Time getTime(int parameterIndex, Calendar cal) throws SQLException
    251      {
    252        String methodCall = "getTime(" + parameterIndex + ", " + cal + ")";
    253        try
    254        {
    255          return (Time) reportReturn(methodCall, realCallableStatement.getTime(parameterIndex, cal));
    256        }
    257        catch (SQLException s)
    258        {
    259          reportException(methodCall, s);
    260          throw s;
    261        }
    262      }
    263
    264      public Timestamp getTimestamp(String parameterName) throws SQLException
    265      {
    266        String methodCall = "getTimestamp(" + parameterName + ")";
    267        try
    268        {
    269          return (Timestamp) reportReturn(methodCall, realCallableStatement.getTimestamp(parameterName));
    270        }
    271        catch (SQLException s)
    272        {
    273          reportException(methodCall, s);
    274          throw s;
    275        }
    276      }
    277
    278      public void setTimestamp(String parameterName, Timestamp x) throws SQLException
    279      {
    280        String methodCall = "setTimestamp(" + parameterName + ", " + x + ")";
    281        try
    282        {
    283          realCallableStatement.setTimestamp(parameterName, x);
    284        }
    285        catch (SQLException s)
    286        {
    287          reportException(methodCall, s);
    288          throw s;
    289        }
    290        reportReturn(methodCall);
    291      }
    292
    293      public String getString(int parameterIndex) throws SQLException
    294      {
    295        String methodCall = "getString(" + parameterIndex + ")";
    296        try
    297        {
    298          return (String) reportReturn(methodCall, realCallableStatement.getString(parameterIndex));
    299        }
    300        catch (SQLException s)
    301        {
    302          reportException(methodCall, s);
    303          throw s;
    304        }
    305      }
    306
    307      public void registerOutParameter(int parameterIndex, int sqlType) throws SQLException
    308      {
    309        String methodCall = "registerOutParameter(" + parameterIndex + ", " + sqlType + ")";
    310        argTraceSet(parameterIndex, null, "<OUT>");
    311        try
    312        {
    313          realCallableStatement.registerOutParameter(parameterIndex, sqlType);
    314        }
    315        catch (SQLException s)
    316        {
    317          reportException(methodCall, s);
    318          throw s;
    319        }
    320        reportReturn(methodCall);
    321      }
    322
    323      public void registerOutParameter(int parameterIndex, int sqlType, int scale) throws SQLException
    324      {
    325        String methodCall = "registerOutParameter(" + parameterIndex + ", " + sqlType + ", " + scale + ")";
    326        argTraceSet(parameterIndex, null, "<OUT>");
    327        try
    328        {
    329          realCallableStatement.registerOutParameter(parameterIndex, sqlType, scale);
    330        }
    331        catch (SQLException s)
    332        {
    333          reportException(methodCall, s);
    334          throw s;
    335        }
    336        reportReturn(methodCall);
    337      }
    338
    339      public void registerOutParameter(int paramIndex, int sqlType, String typeName) throws SQLException
    340      {
    341        String methodCall = "registerOutParameter(" + paramIndex + ", " + sqlType + ", " + typeName + ")";
    342        argTraceSet(paramIndex, null, "<OUT>");
    343        try
    344        {
    345          realCallableStatement.registerOutParameter(paramIndex, sqlType, typeName);
    346        }
    347        catch (SQLException s)
    348        {
    349          reportException(methodCall, s);
    350          throw s;
    351        }
    352        reportReturn(methodCall);
    353      }
    354
    355      public byte getByte(String parameterName) throws SQLException
    356      {
    357        String methodCall = "getByte(" + parameterName + ")";
    358        try
    359        {
    360          return reportReturn(methodCall, realCallableStatement.getByte(parameterName));
    361        }
    362        catch (SQLException s)
    363        {
    364          reportException(methodCall, s);
    365          throw s;
    366        }
    367      }
    368
    369      public double getDouble(String parameterName) throws SQLException
    370      {
    371        String methodCall = "getDouble(" + parameterName + ")";
    372        try
    373        {
    374          return reportReturn(methodCall, realCallableStatement.getDouble(parameterName));
    375        }
    376        catch (SQLException s)
    377        {
    378          reportException(methodCall, s);
    379          throw s;
    380        }
    381      }
    382
    383      public float getFloat(String parameterName) throws SQLException
    384      {
    385        String methodCall = "getFloat(" + parameterName + ")";
    386        try
    387        {
    388          return reportReturn(methodCall, realCallableStatement.getFloat(parameterName));
    389        }
    390        catch (SQLException s)
    391        {
    392          reportException(methodCall, s);
    393          throw s;
    394        }
    395      }
    396
    397      public int getInt(String parameterName) throws SQLException
    398      {
    399        String methodCall = "getInt(" + parameterName + ")";
    400        try
    401        {
    402          return reportReturn(methodCall, realCallableStatement.getInt(parameterName));
    403        }
    404        catch (SQLException s)
    405        {
    406          reportException(methodCall, s);
    407          throw s;
    408        }
    409      }
    410
    411      public long getLong(String parameterName) throws SQLException
    412      {
    413        String methodCall = "getLong(" + parameterName + ")";
    414        try
    415        {
    416          return reportReturn(methodCall, realCallableStatement.getLong(parameterName));
    417        }
    418        catch (SQLException s)
    419        {
    420          reportException(methodCall, s);
    421          throw s;
    422        }
    423      }
    424
    425      public short getShort(String parameterName) throws SQLException
    426      {
    427        String methodCall = "getShort(" + parameterName + ")";
    428        try
    429        {
    430          return reportReturn(methodCall, realCallableStatement.getShort(parameterName));
    431        }
    432        catch (SQLException s)
    433        {
    434          reportException(methodCall, s);
    435          throw s;
    436        }
    437      }
    438
    439      public boolean getBoolean(String parameterName) throws SQLException
    440      {
    441        String methodCall = "getBoolean(" + parameterName + ")";
    442        try
    443        {
    444          return reportReturn(methodCall, realCallableStatement.getBoolean(parameterName));
    445        }
    446        catch (SQLException s)
    447        {
    448          reportException(methodCall, s);
    449          throw s;
    450        }
    451      }
    452
    453      public byte[] getBytes(String parameterName) throws SQLException
    454      {
    455        String methodCall = "getBytes(" + parameterName + ")";
    456        try
    457        {
    458          return (byte[]) reportReturn(methodCall, realCallableStatement.getBytes(parameterName));
    459        }
    460        catch (SQLException s)
    461        {
    462          reportException(methodCall, s);
    463          throw s;
    464        }
    465      }
    466
    467      public void setByte(String parameterName, byte x) throws SQLException
    468      {
    469        String methodCall = "setByte(" + parameterName + ", " + x + ")";
    470        try
    471        {
    472          realCallableStatement.setByte(parameterName, x);
    473        }
    474        catch (SQLException s)
    475        {
    476          reportException(methodCall, s);
    477          throw s;
    478        }
    479        reportReturn(methodCall);
    480      }
    481
    482      public void setDouble(String parameterName, double x) throws SQLException
    483      {
    484        String methodCall = "setDouble(" + parameterName + ", " + x + ")";
    485        try
    486        {
    487          realCallableStatement.setDouble(parameterName, x);
    488        }
    489        catch (SQLException s)
    490        {
    491          reportException(methodCall, s);
    492          throw s;
    493        }
    494        reportReturn(methodCall);
    495      }
    496
    497      public void setFloat(String parameterName, float x) throws SQLException
    498      {
    499        String methodCall = "setFloat(" + parameterName + ", " + x + ")";
    500        try
    501        {
    502          realCallableStatement.setFloat(parameterName, x);
    503        }
    504        catch (SQLException s)
    505        {
    506          reportException(methodCall, s);
    507          throw s;
    508        }
    509        reportReturn(methodCall);
    510      }
    511
    512      public void registerOutParameter(String parameterName, int sqlType) throws SQLException
    513      {
    514        String methodCall = "registerOutParameter(" + parameterName + ", " + sqlType + ")";
    515        try
    516        {
    517          realCallableStatement.registerOutParameter(parameterName, sqlType);
    518        }
    519        catch (SQLException s)
    520        {
    521          reportException(methodCall, s);
    522          throw s;
    523        }
    524        reportReturn(methodCall);
    525      }
    526
    527      public void setInt(String parameterName, int x) throws SQLException
    528      {
    529        String methodCall = "setInt(" + parameterName + ", " + x + ")";
    530        try
    531        {
    532          realCallableStatement.setInt(parameterName, x);
    533        }
    534        catch (SQLException s)
    535        {
    536          reportException(methodCall, s);
    537          throw s;
    538        }
    539        reportReturn(methodCall);
    540      }
    541
    542      public void setNull(String parameterName, int sqlType) throws SQLException
    543      {
    544        String methodCall = "setNull(" + parameterName + ", " + sqlType + ")";
    545        try
    546        {
    547          realCallableStatement.setNull(parameterName, sqlType);
    548        }
    549        catch (SQLException s)
    550        {
    551          reportException(methodCall, s);
    552          throw s;
    553        }
    554        reportReturn(methodCall);
    555      }
    556
    557      public void registerOutParameter(String parameterName, int sqlType, int scale) throws SQLException
    558      {
    559        String methodCall = "registerOutParameter(" + parameterName + ", " + sqlType + ", " + scale + ")";
    560        try
    561        {
    562          realCallableStatement.registerOutParameter(parameterName, sqlType, scale);
    563        }
    564        catch (SQLException s)
    565        {
    566          reportException(methodCall, s);
    567          throw s;
    568        }
    569        reportReturn(methodCall);
    570      }
    571
    572      public void setLong(String parameterName, long x) throws SQLException
    573      {
    574        String methodCall = "setLong(" + parameterName + ", " + x + ")";
    575        try
    576        {
    577          realCallableStatement.setLong(parameterName, x);
    578        }
    579        catch (SQLException s)
    580        {
    581          reportException(methodCall, s);
    582          throw s;
    583        }
    584        reportReturn(methodCall);
    585      }
    586
    587      public void setShort(String parameterName, short x) throws SQLException
    588      {
    589        String methodCall = "setShort(" + parameterName + ", " + x + ")";
    590        try
    591        {
    592          realCallableStatement.setShort(parameterName, x);
    593        }
    594        catch (SQLException s)
    595        {
    596          reportException(methodCall, s);
    597          throw s;
    598        }
    599        reportReturn(methodCall);
    600      }
    601
    602      public void setBoolean(String parameterName, boolean x) throws SQLException
    603      {
    604        String methodCall = "setBoolean(" + parameterName + ", " + x + ")";
    605        try
    606        {
    607          realCallableStatement.setBoolean(parameterName, x);
    608        }
    609        catch (SQLException s)
    610        {
    611          reportException(methodCall, s);
    612          throw s;
    613        }
    614        reportReturn(methodCall);
    615      }
    616
    617      public void setBytes(String parameterName, byte[] x) throws SQLException
    618      {
    619        //todo: dump byte array?
    620        String methodCall = "setBytes(" + parameterName + ", " + x + ")";
    621        try
    622        {
    623          realCallableStatement.setBytes(parameterName, x);
    624        }
    625        catch (SQLException s)
    626        {
    627          reportException(methodCall, s);
    628          throw s;
    629        }
    630        reportReturn(methodCall);
    631      }
    632
    633      public boolean getBoolean(int parameterIndex) throws SQLException
    634      {
    635        String methodCall = "getBoolean(" + parameterIndex + ")";
    636        try
    637        {
    638          return reportReturn(methodCall, realCallableStatement.getBoolean(parameterIndex));
    639        }
    640        catch (SQLException s)
    641        {
    642          reportException(methodCall, s);
    643          throw s;
    644        }
    645      }
    646
    647      public Timestamp getTimestamp(int parameterIndex) throws SQLException
    648      {
    649        String methodCall = "getTimestamp(" + parameterIndex + ")";
    650        try
    651        {
    652          return (Timestamp) reportReturn(methodCall, realCallableStatement.getTimestamp(parameterIndex));
    653        }
    654        catch (SQLException s)
    655        {
    656          reportException(methodCall, s);
    657          throw s;
    658        }
    659      }
    660
    661      public void setAsciiStream(String parameterName, InputStream x, int length) throws SQLException
    662      {
    663        String methodCall = "setAsciiStream(" + parameterName + ", " + x + ", " + length + ")";
    664        try
    665        {
    666          realCallableStatement.setAsciiStream(parameterName, x, length);
    667        }
    668        catch (SQLException s)
    669        {
    670          reportException(methodCall, s);
    671          throw s;
    672        }
    673        reportReturn(methodCall);
    674      }
    675
    676      public void setBinaryStream(String parameterName, InputStream x, int length) throws SQLException
    677      {
    678        String methodCall = "setBinaryStream(" + parameterName + ", " + x + ", " + length + ")";
    679        try
    680        {
    681          realCallableStatement.setBinaryStream(parameterName, x, length);
    682        }
    683        catch (SQLException s)
    684        {
    685          reportException(methodCall, s);
    686          throw s;
    687        }
    688        reportReturn(methodCall);
    689      }
    690
    691      public void setCharacterStream(String parameterName, Reader reader, int length) throws SQLException
    692      {
    693        String methodCall = "setCharacterStream(" + parameterName + ", " + reader + ", " + length + ")";
    694        try
    695        {
    696          realCallableStatement.setCharacterStream(parameterName, reader, length);
    697        }
    698        catch (SQLException s)
    699        {
    700          reportException(methodCall, s);
    701          throw s;
    702        }
    703        reportReturn(methodCall);
    704      }
    705
    706      public Object getObject(String parameterName) throws SQLException
    707      {
    708        String methodCall = "getObject(" + parameterName + ")";
    709        try
    710        {
    711          return reportReturn(methodCall, realCallableStatement.getObject(parameterName));
    712        }
    713        catch (SQLException s)
    714        {
    715          reportException(methodCall, s);
    716          throw s;
    717        }
    718      }
    719
    720      public void setObject(String parameterName, Object x) throws SQLException
    721      {
    722        String methodCall = "setObject(" + parameterName + ", " + x + ")";
    723        try
    724        {
    725          realCallableStatement.setObject(parameterName, x);
    726        }
    727        catch (SQLException s)
    728        {
    729          reportException(methodCall, s);
    730          throw s;
    731        }
    732        reportReturn(methodCall);
    733      }
    734
    735      public void setObject(String parameterName, Object x, int targetSqlType) throws SQLException
    736      {
    737        String methodCall = "setObject(" + parameterName + ", " + x + ", " + targetSqlType + ")";
    738        try
    739        {
    740          realCallableStatement.setObject(parameterName, x, targetSqlType);
    741        }
    742        catch (SQLException s)
    743        {
    744          reportException(methodCall, s);
    745          throw s;
    746        }
    747        reportReturn(methodCall);
    748      }
    749
    750      public void setObject(String parameterName, Object x, int targetSqlType, int scale) throws SQLException
    751      {
    752        String methodCall = "setObject(" + parameterName + ", " + x + ", " + targetSqlType + ", " + scale + ")";
    753        try
    754        {
    755          realCallableStatement.setObject(parameterName, x, targetSqlType, scale);
    756        }
    757        catch (SQLException s)
    758        {
    759          reportException(methodCall, s);
    760          throw s;
    761        }
    762        reportReturn(methodCall);
    763      }
    764
    765      public Timestamp getTimestamp(int parameterIndex, Calendar cal) throws SQLException
    766      {
    767        String methodCall = "getTimestamp(" + parameterIndex + ", " + cal + ")";
    768        try
    769        {
    770          return (Timestamp) reportReturn(methodCall, realCallableStatement.getTimestamp(parameterIndex, cal));
    771        }
    772        catch (SQLException s)
    773        {
    774          reportException(methodCall, s);
    775          throw s;
    776        }
    777      }
    778
    779      public Date getDate(String parameterName, Calendar cal) throws SQLException
    780      {
    781        String methodCall = "getDate(" + parameterName + ", " + cal + ")";
    782        try
    783        {
    784          return (Date) reportReturn(methodCall, realCallableStatement.getDate(parameterName, cal));
    785        }
    786        catch (SQLException s)
    787        {
    788          reportException(methodCall, s);
    789          throw s;
    790        }
    791      }
    792
    793      public Time getTime(String parameterName, Calendar cal) throws SQLException
    794      {
    795        String methodCall = "getTime(" + parameterName + ", " + cal + ")";
    796        try
    797        {
    798          return (Time) reportReturn(methodCall, realCallableStatement.getTime(parameterName, cal));
    799        }
    800        catch (SQLException s)
    801        {
    802          reportException(methodCall, s);
    803          throw s;
    804        }
    805      }
    806
    807      public Timestamp getTimestamp(String parameterName, Calendar cal) throws SQLException
    808      {
    809        String methodCall = "getTimestamp(" + parameterName + ", " + cal + ")";
    810        try
    811        {
    812          return (Timestamp) reportReturn(methodCall, realCallableStatement.getTimestamp(parameterName, cal));
    813        }
    814        catch (SQLException s)
    815        {
    816          reportException(methodCall, s);
    817          throw s;
    818        }
    819      }
    820
    821      public void setDate(String parameterName, Date x, Calendar cal) throws SQLException
    822      {
    823        String methodCall = "setDate(" + parameterName + ", " + x + ", " + cal + ")";
    824        try
    825        {
    826          realCallableStatement.setDate(parameterName, x, cal);
    827        }
    828        catch (SQLException s)
    829        {
    830          reportException(methodCall, s);
    831          throw s;
    832        }
    833        reportReturn(methodCall);
    834      }
    835
    836      public void setTime(String parameterName, Time x, Calendar cal) throws SQLException
    837      {
    838        String methodCall = "setTime(" + parameterName + ", " + x + ", " + cal + ")";
    839        try
    840        {
    841          realCallableStatement.setTime(parameterName, x, cal);
    842        }
    843        catch (SQLException s)
    844        {
    845          reportException(methodCall, s);
    846          throw s;
    847        }
    848        reportReturn(methodCall);
    849      }
    850
    851      public void setTimestamp(String parameterName, Timestamp x, Calendar cal) throws SQLException
    852      {
    853        String methodCall = "setTimestamp(" + parameterName + ", " + x + ", " + cal + ")";
    854        try
    855        {
    856          realCallableStatement.setTimestamp(parameterName, x, cal);
    857        }
    858        catch (SQLException s)
    859        {
    860          reportException(methodCall, s);
    861          throw s;
    862        }
    863        reportReturn(methodCall);
    864      }
    865
    866      public short getShort(int parameterIndex) throws SQLException
    867      {
    868        String methodCall = "getShort(" + parameterIndex + ")";
    869        try
    870        {
    871          return reportReturn(methodCall, realCallableStatement.getShort(parameterIndex));
    872        }
    873        catch (SQLException s)
    874        {
    875          reportException(methodCall, s);
    876          throw s;
    877        }
    878      }
    879
    880      public long getLong(int parameterIndex) throws SQLException
    881      {
    882        String methodCall = "getLong(" + parameterIndex + ")";
    883        try
    884        {
    885          return reportReturn(methodCall, realCallableStatement.getLong(parameterIndex));
    886        }
    887        catch (SQLException s)
    888        {
    889          reportException(methodCall, s);
    890          throw s;
    891        }
    892      }
    893
    894      public float getFloat(int parameterIndex) throws SQLException
    895      {
    896        String methodCall = "getFloat(" + parameterIndex + ")";
    897        try
    898        {
    899          return reportReturn(methodCall, realCallableStatement.getFloat(parameterIndex));
    900        }
    901        catch (SQLException s)
    902        {
    903          reportException(methodCall, s);
    904          throw s;
    905        }
    906      }
    907
    908      public Ref getRef(int i) throws SQLException
    909      {
    910        String methodCall = "getRef(" + i + ")";
    911        try
    912        {
    913          return (Ref) reportReturn(methodCall, realCallableStatement.getRef(i));
    914        }
    915        catch (SQLException s)
    916        {
    917          reportException(methodCall, s);
    918          throw s;
    919        }
    920      }
    921
    922      /**
    923       * @deprecated
    924       */
    925      public BigDecimal getBigDecimal(int parameterIndex, int scale) throws SQLException
    926      {
    927        String methodCall = "getBigDecimal(" + parameterIndex + ", " + scale + ")";
    928        try
    929        {
    930          return (BigDecimal) reportReturn(methodCall, realCallableStatement.getBigDecimal(parameterIndex, scale));
    931        }
    932        catch (SQLException s)
    933        {
    934          reportException(methodCall, s);
    935          throw s;
    936        }
    937      }
    938
    939      public URL getURL(int parameterIndex) throws SQLException
    940      {
    941        String methodCall = "getURL(" + parameterIndex + ")";
    942        try
    943        {
    944          return (URL) reportReturn(methodCall, realCallableStatement.getURL(parameterIndex));
    945        }
    946        catch (SQLException s)
    947        {
    948          reportException(methodCall, s);
    949          throw s;
    950        }
    951
    952      }
    953
    954      public BigDecimal getBigDecimal(int parameterIndex) throws SQLException
    955      {
    956        String methodCall = "getBigDecimal(" + parameterIndex + ")";
    957        try
    958        {
    959          return (BigDecimal) reportReturn(methodCall, realCallableStatement.getBigDecimal(parameterIndex));
    960        }
    961        catch (SQLException s)
    962        {
    963          reportException(methodCall, s);
    964          throw s;
    965        }
    966      }
    967
    968      public byte getByte(int parameterIndex) throws SQLException
    969      {
    970        String methodCall = "getByte(" + parameterIndex + ")";
    971        try
    972        {
    973          return reportReturn(methodCall, realCallableStatement.getByte(parameterIndex));
    974        }
    975        catch (SQLException s)
    976        {
    977          reportException(methodCall, s);
    978          throw s;
    979        }
    980      }
    981
    982      public Object getObject(int parameterIndex) throws SQLException
    983      {
    984        String methodCall = "getObject(" + parameterIndex + ")";
    985        try
    986        {
    987          return reportReturn(methodCall, realCallableStatement.getObject(parameterIndex));
    988        }
    989        catch (SQLException s)
    990        {
    991          reportException(methodCall, s);
    992          throw s;
    993        }
    994      }
    995
    996      public Object getObject(int i, Map map) throws SQLException
    997      {
    998        String methodCall = "getObject(" + i + ", " + map + ")";
    999        try
    1000        {
    1001          return reportReturn(methodCall, realCallableStatement.getObject(i, map));
    1002        }
    1003        catch (SQLException s)
    1004        {
    1005          reportException(methodCall, s);
    1006          throw s;
    1007        }
    1008      }
    1009
    1010      public String getString(String parameterName) throws SQLException
    1011      {
    1012        String methodCall = "getString(" + parameterName + ")";
    1013        try
    1014        {
    1015          return (String) reportReturn(methodCall, realCallableStatement.getString(parameterName));
    1016        }
    1017        catch (SQLException s)
    1018        {
    1019          reportException(methodCall, s);
    1020          throw s;
    1021        }
    1022      }
    1023
    1024      public void registerOutParameter(String parameterName, int sqlType, String typeName) throws SQLException
    1025      {
    1026        String methodCall = "registerOutParameter(" + parameterName + ", " + sqlType + ", " + typeName + ")";
    1027        try
    1028        {
    1029          realCallableStatement.registerOutParameter(parameterName, sqlType, typeName);
    1030        }
    1031        catch (SQLException s)
    1032        {
    1033          reportException(methodCall, s);
    1034          throw s;
    1035        }
    1036        reportReturn(methodCall);
    1037      }
    1038
    1039      public void setNull(String parameterName, int sqlType, String typeName) throws SQLException
    1040      {
    1041        String methodCall = "setNull(" + parameterName + ", " + sqlType + ", " + typeName + ")";
    1042        try
    1043        {
    1044          realCallableStatement.setNull(parameterName, sqlType, typeName);
    1045        }
    1046        catch (SQLException s)
    1047        {
    1048          reportException(methodCall, s);
    1049          throw s;
    1050        }
    1051        reportReturn(methodCall);
    1052      }
    1053
    1054      public void setString(String parameterName, String x) throws SQLException
    1055      {
    1056        String methodCall = "setString(" + parameterName + ", " + x + ")";
    1057
    1058        try
    1059        {
    1060          realCallableStatement.setString(parameterName, x);
    1061        }
    1062        catch (SQLException s)
    1063        {
    1064          reportException(methodCall, s);
    1065          throw s;
    1066        }
    1067        reportReturn(methodCall);
    1068      }
    1069
    1070      public BigDecimal getBigDecimal(String parameterName) throws SQLException
    1071      {
    1072        String methodCall = "getBigDecimal(" + parameterName + ")";
    1073        try
    1074        {
    1075          return (BigDecimal) reportReturn(methodCall, realCallableStatement.getBigDecimal(parameterName));
    1076        }
    1077        catch (SQLException s)
    1078        {
    1079          reportException(methodCall, s);
    1080          throw s;
    1081        }
    1082      }
    1083
    1084      public Object getObject(String parameterName, Map<String, Class<?>> map) throws SQLException {
    1085        String methodCall = "getObject(" + parameterName + ", " + map + ")";
    1086        try
    1087        {
    1088          return reportReturn(methodCall, realCallableStatement.getObject(parameterName, map));
    1089        }
    1090        catch (SQLException s)
    1091        {
    1092          reportException(methodCall, s);
    1093          throw s;
    1094        }
    1095      }
    1096
    1097      public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException
    1098      {
    1099        String methodCall = "setBigDecimal(" + parameterName + ", " + x + ")";
    1100        try
    1101        {
    1102          realCallableStatement.setBigDecimal(parameterName, x);
    1103        }
    1104        catch (SQLException s)
    1105        {
    1106          reportException(methodCall, s);
    1107          throw s;
    1108        }
    1109        reportReturn(methodCall);
    1110      }
    1111
    1112      public URL getURL(String parameterName) throws SQLException
    1113      {
    1114        String methodCall = "getURL(" + parameterName + ")";
    1115        try
    1116        {
    1117          return (URL) reportReturn(methodCall, realCallableStatement.getURL(parameterName));
    1118        }
    1119        catch (SQLException s)
    1120        {
    1121          reportException(methodCall, s);
    1122          throw s;
    1123        }
    1124      }
    1125
    1126      public RowId getRowId(int parameterIndex) throws SQLException {
    1127        String methodCall = "getRowId(" + parameterIndex + ")";
    1128        try
    1129        {
    1130          return (RowId) reportReturn(methodCall, realCallableStatement.getRowId(parameterIndex));
    1131        }
    1132        catch (SQLException s)
    1133        {
    1134          reportException(methodCall, s);
    1135          throw s;
    1136        }
    1137      }
    1138
    1139      public RowId getRowId(String parameterName) throws SQLException {
    1140        String methodCall = "getRowId(" + parameterName + ")";
    1141        try
    1142        {
    1143          return (RowId) reportReturn(methodCall, realCallableStatement.getRowId(parameterName));
    1144        }
    1145        catch (SQLException s)
    1146        {
    1147          reportException(methodCall, s);
    1148          throw s;
    1149        }
    1150      }
    1151
    1152      public void setRowId(String parameterName, RowId x) throws SQLException {
    1153        String methodCall = "setRowId(" + parameterName + ", " + x + ")";
    1154        try
    1155        {
    1156          realCallableStatement.setRowId(parameterName, x);
    1157        }
    1158        catch (SQLException s)
    1159        {
    1160          reportException(methodCall, s);
    1161          throw s;
    1162        }
    1163        reportReturn(methodCall);
    1164      }
    1165
    1166      public void setNString(String parameterName, String value) throws SQLException {
    1167        String methodCall = "setNString(" + parameterName + ", " + value + ")";
    1168        try
    1169        {
    1170          realCallableStatement.setNString(parameterName, value);
    1171        }
    1172        catch (SQLException s)
    1173        {
    1174          reportException(methodCall, s);
    1175          throw s;
    1176        }
    1177        reportReturn(methodCall);
    1178      }
    1179
    1180      public void setNCharacterStream(String parameterName, Reader reader, long length) throws SQLException {
    1181        String methodCall = "setNCharacterStream(" + parameterName + ", " + reader + ", " + length + ")";
    1182        try
    1183        {
    1184          realCallableStatement.setNCharacterStream(parameterName, reader, length);
    1185        }
    1186        catch (SQLException s)
    1187        {
    1188          reportException(methodCall, s);
    1189          throw s;
    1190        }
    1191        reportReturn(methodCall);
    1192      }
    1193
    1194      public void setNClob(String parameterName, NClob value) throws SQLException {
    1195        String methodCall = "setNClob(" + parameterName + ", " + value + ")";
    1196        try
    1197        {
    1198          realCallableStatement.setNClob(parameterName, value);
    1199        }
    1200        catch (SQLException s)
    1201        {
    1202          reportException(methodCall, s);
    1203          throw s;
    1204        }
    1205        reportReturn(methodCall);
    1206      }
    1207
    1208      public void setClob(String parameterName, Reader reader, long length) throws SQLException {
    1209        String methodCall = "setClob(" + parameterName + ", " + reader + ", " + length + ")";
    1210        try
    1211        {
    1212          realCallableStatement.setClob(parameterName, reader, length);
    1213        }
    1214        catch (SQLException s)
    1215        {
    1216          reportException(methodCall, s);
    1217          throw s;
    1218        }
    1219        reportReturn(methodCall);
    1220      }
    1221
    1222      public void setBlob(String parameterName, InputStream inputStream, long length) throws SQLException {
    1223        String methodCall = "setBlob(" + parameterName + ", " + inputStream + ", " + length + ")";
    1224        try
    1225        {
    1226          realCallableStatement.setBlob(parameterName, inputStream, length);
    1227        }
    1228        catch (SQLException s)
    1229        {
    1230          reportException(methodCall, s);
    1231          throw s;
    1232        }
    1233        reportReturn(methodCall);
    1234      }
    1235
    1236      public void setNClob(String parameterName, Reader reader, long length) throws SQLException {
    1237        String methodCall = "setNClob(" + parameterName + ", " + reader + ", " + length + ")";
    1238        try
    1239        {
    1240          realCallableStatement.setNClob(parameterName, reader, length);
    1241        }
    1242        catch (SQLException s)
    1243        {
    1244          reportException(methodCall, s);
    1245          throw s;
    1246        }
    1247        reportReturn(methodCall);
    1248      }
    1249
    1250      public NClob getNClob(int parameterIndex) throws SQLException {
    1251        String methodCall = "getNClob(" + parameterIndex + ")";
    1252        try
    1253        {
    1254          return (NClob) reportReturn(methodCall, realCallableStatement.getNClob(parameterIndex));
    1255        }
    1256        catch (SQLException s)
    1257        {
    1258          reportException(methodCall, s);
    1259          throw s;
    1260        }
    1261      }
    1262
    1263      public NClob getNClob(String parameterName) throws SQLException {
    1264        String methodCall = "getNClob(" + parameterName + ")";
    1265        try
    1266        {
    1267          return (NClob) reportReturn(methodCall, realCallableStatement.getNClob(parameterName));
    1268        }
    1269        catch (SQLException s)
    1270        {
    1271          reportException(methodCall, s);
    1272          throw s;
    1273        }
    1274      }
    1275
    1276      public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException {
    1277        String methodCall = "setSQLXML(" + parameterName + ", " + xmlObject + ")";
    1278        try
    1279        {
    1280          realCallableStatement.setSQLXML(parameterName, xmlObject);
    1281        }
    1282        catch (SQLException s)
    1283        {
    1284          reportException(methodCall, s);
    1285          throw s;
    1286        }
    1287        reportReturn(methodCall);
    1288      }
    1289
    1290      public SQLXML getSQLXML(int parameterIndex) throws SQLException {
    1291        String methodCall = "getSQLXML(" + parameterIndex + ")";
    1292        try
    1293        {
    1294          return (SQLXML) reportReturn(methodCall, realCallableStatement.getSQLXML(parameterIndex));
    1295        }
    1296        catch (SQLException s)
    1297        {
    1298          reportException(methodCall, s);
    1299          throw s;
    1300        }
    1301      }
    1302
    1303      public SQLXML getSQLXML(String parameterName) throws SQLException {
    1304        String methodCall = "getSQLXML(" + parameterName + ")";
    1305        try
    1306        {
    1307          return (SQLXML) reportReturn(methodCall, realCallableStatement.getSQLXML(parameterName));
    1308        }
    1309        catch (SQLException s)
    1310        {
    1311          reportException(methodCall, s);
    1312          throw s;
    1313        }
    1314
    1315      }
    1316
    1317      public String getNString(int parameterIndex) throws SQLException {
    1318        String methodCall = "getNString(" + parameterIndex + ")";
    1319        try
    1320        {
    1321          return (String) reportReturn(methodCall, realCallableStatement.getNString(parameterIndex));
    1322        }
    1323        catch (SQLException s)
    1324        {
    1325          reportException(methodCall, s);
    1326          throw s;
    1327        }
    1328      }
    1329
    1330      public String getNString(String parameterName) throws SQLException {
    1331        String methodCall = "getNString(" + parameterName + ")";
    1332        try
    1333        {
    1334          return (String) reportReturn(methodCall, realCallableStatement.getNString(parameterName));
    1335        }
    1336        catch (SQLException s)
    1337        {
    1338          reportException(methodCall, s);
    1339          throw s;
    1340        }
    1341      }
    1342
    1343      public Reader getNCharacterStream(int parameterIndex) throws SQLException {
    1344        String methodCall = "getNCharacterStream(" + parameterIndex + ")";
    1345        try
    1346        {
    1347          return (Reader) reportReturn(methodCall, realCallableStatement.getNCharacterStream(parameterIndex));
    1348        }
    1349        catch (SQLException s)
    1350        {
    1351          reportException(methodCall, s);
    1352          throw s;
    1353        }
    1354      }
    1355
    1356      public Reader getNCharacterStream(String parameterName) throws SQLException {
    1357        String methodCall = "getNCharacterStream(" + parameterName + ")";
    1358        try
    1359        {
    1360          return (Reader) reportReturn(methodCall, realCallableStatement.getNCharacterStream(parameterName));
    1361        }
    1362        catch (SQLException s)
    1363        {
    1364          reportException(methodCall, s);
    1365          throw s;
    1366        }
    1367      }
    1368
    1369      public Reader getCharacterStream(int parameterIndex) throws SQLException {
    1370        String methodCall = "getCharacterStream(" + parameterIndex + ")";
    1371        try
    1372        {
    1373          return (Reader) reportReturn(methodCall, realCallableStatement.getCharacterStream(parameterIndex));
    1374        }
    1375        catch (SQLException s)
    1376        {
    1377          reportException(methodCall, s);
    1378          throw s;
    1379        }
    1380      }
    1381
    1382      public Reader getCharacterStream(String parameterName) throws SQLException {
    1383        String methodCall = "getCharacterStream(" + parameterName + ")";
    1384        try
    1385        {
    1386          return (Reader) reportReturn(methodCall, realCallableStatement.getCharacterStream(parameterName));
    1387        }
    1388        catch (SQLException s)
    1389        {
    1390          reportException(methodCall, s);
    1391          throw s;
    1392        }
    1393      }
    1394
    1395      public void setBlob(String parameterName, Blob x) throws SQLException {
    1396        String methodCall = "setBlob(" + parameterName + ", " + x + ")";
    1397        try
    1398        {
    1399          realCallableStatement.setBlob(parameterName, x);
    1400        }
    1401        catch (SQLException s)
    1402        {
    1403          reportException(methodCall, s);
    1404          throw s;
    1405        }
    1406        reportReturn(methodCall);
    1407      }
    1408
    1409      public void setClob(String parameterName, Clob x) throws SQLException {
    1410        String methodCall = "setClob(" + parameterName + ", " + x + ")";
    1411        try
    1412        {
    1413          realCallableStatement.setClob(parameterName, x);
    1414        }
    1415        catch (SQLException s)
    1416        {
    1417          reportException(methodCall, s);
    1418          throw s;
    1419        }
    1420        reportReturn(methodCall);
    1421      }
    1422
    1423      public void setAsciiStream(String parameterName, InputStream x, long length) throws SQLException {
    1424        String methodCall = "setAsciiStream(" + parameterName + ", " + x + ", " + length + ")";
    1425        try
    1426        {
    1427          realCallableStatement.setAsciiStream(parameterName, x, length);
    1428        }
    1429        catch (SQLException s)
    1430        {
    1431          reportException(methodCall, s);
    1432          throw s;
    1433        }
    1434        reportReturn(methodCall);
    1435      }
    1436
    1437      public void setBinaryStream(String parameterName, InputStream x, long length) throws SQLException {
    1438        String methodCall = "setBinaryStream(" + parameterName + ", " + x + ", " + length + ")";
    1439        try
    1440        {
    1441          realCallableStatement.setBinaryStream(parameterName, x, length);
    1442        }
    1443        catch (SQLException s)
    1444        {
    1445          reportException(methodCall, s);
    1446          throw s;
    1447        }
    1448        reportReturn(methodCall);
    1449      }
    1450
    1451      public void setCharacterStream(String parameterName, Reader reader, long length) throws SQLException {
    1452        String methodCall = "setCharacterStream(" + parameterName + ", " + reader + ", " + length + ")";
    1453        try
    1454        {
    1455          realCallableStatement.setCharacterStream(parameterName, reader, length);
    1456        }
    1457        catch (SQLException s)
    1458        {
    1459          reportException(methodCall, s);
    1460          throw s;
    1461        }
    1462        reportReturn(methodCall);
    1463      }
    1464
    1465      public void setAsciiStream(String parameterName, InputStream x) throws SQLException {
    1466        String methodCall = "setAsciiStream(" + parameterName + ", " + x + ")";
    1467        try
    1468        {
    1469          realCallableStatement.setAsciiStream(parameterName, x);
    1470        }
    1471        catch (SQLException s)
    1472        {
    1473          reportException(methodCall, s);
    1474          throw s;
    1475        }
    1476        reportReturn(methodCall);
    1477      }
    1478
    1479      public void setBinaryStream(String parameterName, InputStream x) throws SQLException {
    1480        String methodCall = "setBinaryStream(" + parameterName + ", " + x + ")";
    1481        try
    1482        {
    1483          realCallableStatement.setBinaryStream(parameterName, x);
    1484        }
    1485        catch (SQLException s)
    1486        {
    1487          reportException(methodCall, s);
    1488          throw s;
    1489        }
    1490        reportReturn(methodCall);
    1491      }
    1492
    1493      public void setCharacterStream(String parameterName, Reader reader) throws SQLException {
    1494        String methodCall = "setCharacterStream(" + parameterName + ", " + reader + ")";
    1495        try
    1496        {
    1497          realCallableStatement.setCharacterStream(parameterName, reader);
    1498        }
    1499        catch (SQLException s)
    1500        {
    1501          reportException(methodCall, s);
    1502          throw s;
    1503        }
    1504        reportReturn(methodCall);
    1505      }
    1506
    1507      public void setNCharacterStream(String parameterName, Reader reader) throws SQLException {
    1508        String methodCall = "setNCharacterStream(" + parameterName + ", " + reader + ")";
    1509        try
    1510        {
    1511          realCallableStatement.setNCharacterStream(parameterName, reader);
    1512        }
    1513        catch (SQLException s)
    1514        {
    1515          reportException(methodCall, s);
    1516          throw s;
    1517        }
    1518        reportReturn(methodCall);
    1519      }
    1520
    1521      public void setClob(String parameterName, Reader reader) throws SQLException {
    1522        String methodCall = "setClob(" + parameterName + ", " + reader + ")";
    1523        try
    1524        {
    1525          realCallableStatement.setClob(parameterName, reader);
    1526        }
    1527        catch (SQLException s)
    1528        {
    1529          reportException(methodCall, s);
    1530          throw s;
    1531        }
    1532        reportReturn(methodCall);
    1533      }
    1534
    1535      public void setBlob(String parameterName, InputStream inputStream) throws SQLException {
    1536        String methodCall = "setBlob(" + parameterName + ", " + inputStream + ")";
    1537        try
    1538        {
    1539          realCallableStatement.setBlob(parameterName, inputStream);
    1540        }
    1541        catch (SQLException s)
    1542        {
    1543          reportException(methodCall, s);
    1544          throw s;
    1545        }
    1546        reportReturn(methodCall);
    1547      }
    1548
    1549      public void setNClob(String parameterName, Reader reader) throws SQLException {
    1550        String methodCall = "setNClob(" + parameterName + ", " + reader + ")";
    1551        try
    1552        {
    1553          realCallableStatement.setNClob(parameterName, reader);
    1554        }
    1555        catch (SQLException s)
    1556        {
    1557          reportException(methodCall, s);
    1558          throw s;
    1559        }
    1560        reportReturn(methodCall);
    1561      }
    1562
    1563      public void setURL(String parameterName, URL val) throws SQLException
    1564      {
    1565        String methodCall = "setURL(" + parameterName + ", " + val + ")";
    1566        try
    1567        {
    1568          realCallableStatement.setURL(parameterName, val);
    1569        }
    1570        catch (SQLException s)
    1571        {
    1572          reportException(methodCall, s);
    1573          throw s;
    1574        }
    1575        reportReturn(methodCall);
    1576      }
    1577
    1578      public Array getArray(String parameterName) throws SQLException
    1579      {
    1580        String methodCall = "getURL(" + parameterName + ")";
    1581        try
    1582        {
    1583          return (Array) reportReturn(methodCall, realCallableStatement.getArray(parameterName));
    1584        }
    1585        catch (SQLException s)
    1586        {
    1587          reportException(methodCall, s);
    1588          throw s;
    1589        }
    1590      }
    1591
    1592      public Blob getBlob(String parameterName) throws SQLException
    1593      {
    1594        String methodCall = "getBlob(" + parameterName + ")";
    1595        try
    1596        {
    1597          return (Blob) reportReturn(methodCall, realCallableStatement.getBlob(parameterName));
    1598        }
    1599        catch (SQLException s)
    1600        {
    1601          reportException(methodCall, s);
    1602          throw s;
    1603        }
    1604      }
    1605
    1606      public Clob getClob(String parameterName) throws SQLException
    1607      {
    1608        String methodCall = "getClob(" + parameterName + ")";
    1609        try
    1610        {
    1611          return (Clob) reportReturn(methodCall, realCallableStatement.getClob(parameterName));
    1612        }
    1613        catch (SQLException s)
    1614        {
    1615          reportException(methodCall, s);
    1616          throw s;
    1617        }
    1618      }
    1619
    1620      public Date getDate(String parameterName) throws SQLException
    1621      {
    1622        String methodCall = "getDate(" + parameterName + ")";
    1623        try
    1624        {
    1625          return (Date) reportReturn(methodCall, realCallableStatement.getDate(parameterName));
    1626        }
    1627        catch (SQLException s)
    1628        {
    1629          reportException(methodCall, s);
    1630          throw s;
    1631        }
    1632      }
    1633
    1634      public void setDate(String parameterName, Date x) throws SQLException
    1635      {
    1636        String methodCall = "setDate(" + parameterName + ", " + x + ")";
    1637        try
    1638        {
    1639          realCallableStatement.setDate(parameterName, x);
    1640        }
    1641        catch (SQLException s)
    1642        {
    1643          reportException(methodCall, s);
    1644          throw s;
    1645        }
    1646        reportReturn(methodCall);
    1647      }
    1648
    1649      public <T> T unwrap(Class<T> iface) throws SQLException {
    1650        String methodCall = "unwrap(" + (iface==null?"null":iface.getName()) + ")";
    1651        try
    1652        {
    1653          //todo: double check this logic
    1654          //NOTE: could call super.isWrapperFor to simplify this logic, but it would result in extra log output
    1655          //because the super classes would be invoked, thus executing their logging methods too...
    1656          return (T)reportReturn(methodCall,
    1657            (iface != null && (iface == CallableStatement.class||iface==PreparedStatement.class||
    1658              iface==Statement.class||iface==Spy.class))?
    1659              (T)this:
    1660              realCallableStatement.unwrap(iface));
    1661        }
    1662        catch (SQLException s)
    1663        {
    1664          reportException(methodCall,s);
    1665          throw s;
    1666        }
    1667      }
    1668
    1669      public boolean isWrapperFor(Class<?> iface) throws SQLException
    1670      {
    1671        String methodCall = "isWrapperFor(" + (iface==null?"null":iface.getName()) + ")";
    1672        try
    1673        {
    1674          //NOTE: could call super.isWrapperFor to simplify this logic, but it would result in extra log output
    1675          //when the super classes would be invoked..
    1676          return reportReturn(methodCall,
    1677            (iface != null && (iface == CallableStatement.class||iface==PreparedStatement.class||iface==Statement.class||iface==Spy.class)) ||
    1678            realCallableStatement.isWrapperFor(iface));
    1679        }
    1680        catch (SQLException s)
    1681        {
    1682          reportException(methodCall,s);
    1683          throw s;
    1684        }
    1685      }
    1686
    1687    }