    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    package net.sf.log4jdbc;
    017
    018    import java.io.InputStream;
    019    import java.io.Reader;
    020    import java.math.BigDecimal;
    021    import java.net.URL;
    022    import java.sql.*;
    023    import java.util.Calendar;
    024    import java.util.Map;
    025
    026    /**
    027     * Wraps a ResultSet and reports method calls, returns and exceptions.
    028     *
    029     * JDBC 4 version.
    030     *
    031     * @author Arthur Blake
    032     */
    033    public class ResultSetSpy implements ResultSet, Spy
    034    {
    035      private final SpyLogDelegator log;
    036
    037      /**
    038       * Report an exception to be logged.
    039       *
    040       * @param methodCall description of method call and arguments passed to it that generated the exception.
    041       * @param exception exception that was generated
    042       */
    043      protected void reportException(String methodCall, SQLException exception)
    044      {
    045        log.exceptionOccured(this, methodCall, exception, null, -1L);
    046      }
    047
    048      /**
    049       * Report (for logging) that a method returned.  All the other reportReturn methods are conveniance methods that call
    050       * this method.
    051       *
    052       * @param methodCall description of method call and arguments passed to it that returned.
    053       * @param msg description of what the return value that was returned.  may be an empty String for void return types.
    054       */
    055      protected void reportAllReturns(String methodCall, String msg)
    056      {
    057        log.methodReturned(this, methodCall, msg);
    058      }
    059
    060      private ResultSet realResultSet;
    061      private StatementSpy parent;
    062
    063      /**
    064       * Create a new ResultSetSpy that wraps another ResultSet object, that logs all method calls, expceptions, etc.
    065       *
    066       * @param parent Statement that generated this ResultSet.
    067       * @param realResultSet real underlying ResultSet that is being wrapped.
    068       */
    069      public ResultSetSpy(StatementSpy parent, ResultSet realResultSet)
    070      {
    071        if (realResultSet == null)
    072        {
    073          throw new IllegalArgumentException("Must provide a non null real ResultSet");
    074        }
    075        this.realResultSet = realResultSet;
    076        this.parent = parent;
    077        log = SpyLogFactory.getSpyLogDelegator();
    078      }
    079
    080      /**
    081       * Description for ResultSet class type.
    082       */
    083      public static final String classTypeDescription = "ResultSet";
    084
    085      public String getClassType()
    086      {
    087        return classTypeDescription;
    088      }
    089
    090      public int getConnectionNumber()
    091      {
    092        return parent.getConnectionNumber();
    093      }
    094
    095      /**
    096       * Conveniance method to report (for logging) that a method returned a boolean value.
    097       *
    098       * @param methodCall description of method call and arguments passed to it that returned.
    099       * @param value boolean return value.
    100       * @return the boolean return value as passed in.
    101       */
    102      protected boolean reportReturn(String methodCall, boolean value)
    103      {
    104        reportAllReturns(methodCall, "" + value);
    105        return value;
    106      }
    107
    108      /**
    109       * Conveniance method to report (for logging) that a method returned a byte value.
    110       *
    111       * @param methodCall description of method call and arguments passed to it that returned.
    112       * @param value byte return value.
    113       * @return the byte return value as passed in.
    114       */
    115      protected byte reportReturn(String methodCall, byte value)
    116      {
    117        reportAllReturns(methodCall, "" + value);
    118        return value;
    119      }
    120
    121      /**
    122       * Conveniance method to report (for logging) that a method returned a int value.
    123       *
    124       * @param methodCall description of method call and arguments passed to it that returned.
    125       * @param value int return value.
    126       * @return the int return value as passed in.
    127       */
    128      protected int reportReturn(String methodCall, int value)
    129      {
    130        reportAllReturns(methodCall, "" + value);
    131        return value;
    132      }
    133
    134      /**
    135       * Conveniance method to report (for logging) that a method returned a double value.
    136       *
    137       * @param methodCall description of method call and arguments passed to it that returned.
    138       * @param value double return value.
    139       * @return the double return value as passed in.
    140       */
    141      protected double reportReturn(String methodCall, double value)
    142      {
    143        reportAllReturns(methodCall, "" + value);
    144        return value;
    145      }
    146
    147      /**
    148       * Conveniance method to report (for logging) that a method returned a short value.
    149       *
    150       * @param methodCall description of method call and arguments passed to it that returned.
    151       * @param value short return value.
    152       * @return the short return value as passed in.
    153       */
    154      protected short reportReturn(String methodCall, short value)
    155      {
    156        reportAllReturns(methodCall, "" + value);
    157        return value;
    158      }
    159
    160      /**
    161       * Conveniance method to report (for logging) that a method returned a long value.
    162       *
    163       * @param methodCall description of method call and arguments passed to it that returned.
    164       * @param value long return value.
    165       * @return the long return value as passed in.
    166       */
    167      protected long reportReturn(String methodCall, long value)
    168      {
    169        reportAllReturns(methodCall, "" + value);
    170        return value;
    171      }
    172
    173      /**
    174       * Conveniance method to report (for logging) that a method returned a float value.
    175       *
    176       * @param methodCall description of method call and arguments passed to it that returned.
    177       * @param value float return value.
    178       * @return the float return value as passed in.
    179       */
    180      protected float reportReturn(String methodCall, float value)
    181      {
    182        reportAllReturns(methodCall, "" + value);
    183        return value;
    184      }
    185
    186      /**
    187       * Conveniance method to report (for logging) that a method returned an Object.
    188       *
    189       * @param methodCall description of method call and arguments passed to it that returned.
    190       * @param value return Object.
    191       * @return the return Object as passed in.
    192       */
    193      protected Object reportReturn(String methodCall, Object value)
    194      {
    195        reportAllReturns(methodCall, "" + value);
    196        return value;
    197      }
    198
    199      /**
    200       * Conveniance method to report (for logging) that a method returned (void return type).
    201       *
    202       * @param methodCall description of method call and arguments passed to it that returned.
    203       */
    204      protected void reportReturn(String methodCall)
    205      {
    206        reportAllReturns(methodCall, "");
    207      }
    208
    209      // forwarding methods
    210
    211      public void updateAsciiStream(int columnIndex, InputStream x, int length) throws SQLException
    212      {
    213        String methodCall = "updateAsciiStream(" + columnIndex + ", " + x + ", " + length + ")";
    214        try
    215        {
    216          realResultSet.updateAsciiStream(columnIndex, x, length);
    217        }
    218        catch (SQLException s)
    219        {
    220          reportException(methodCall, s);
    221          throw s;
    222        }
    223        reportReturn(methodCall);
    224      }
    225
    226      public void updateAsciiStream(String columnName, InputStream x, int length) throws SQLException
    227      {
    228        String methodCall = "updateAsciiStream(" + columnName + ", " + x + ", " + length + ")";
    229        try
    230        {
    231          realResultSet.updateAsciiStream(columnName, x, length);
    232        }
    233        catch (SQLException s)
    234        {
    235          reportException(methodCall, s);
    236          throw s;
    237        }
    238        reportReturn(methodCall);
    239      }
    240
    241      public int getRow() throws SQLException
    242      {
    243        String methodCall = "getRow()";
    244        try
    245        {
    246          return reportReturn(methodCall, realResultSet.getRow());
    247        }
    248        catch (SQLException s)
    249        {
    250          reportException(methodCall, s);
    251          throw s;
    252        }
    253      }
    254
    255      public void cancelRowUpdates() throws SQLException
    256      {
    257        String methodCall = "cancelRowUpdates()";
    258        try
    259        {
    260          realResultSet.cancelRowUpdates();
    261        }
    262        catch (SQLException s)
    263        {
    264          reportException(methodCall, s);
    265          throw s;
    266        }
    267        reportReturn(methodCall);
    268      }
    269
    270      public Time getTime(int columnIndex) throws SQLException
    271      {
    272        String methodCall = "getTime(" + columnIndex + ")";
    273        try
    274        {
    275          return (Time) reportReturn(methodCall, realResultSet.getTime(columnIndex));
    276        }
    277        catch (SQLException s)
    278        {
    279          reportException(methodCall, s);
    280          throw s;
    281        }
    282      }
    283
    284      public Time getTime(String columnName) throws SQLException
    285      {
    286        String methodCall = "getTime(" + columnName + ")";
    287        try
    288        {
    289          return (Time) reportReturn(methodCall, realResultSet.getTime(columnName));
    290        }
    291        catch (SQLException s)
    292        {
    293          reportException(methodCall, s);
    294          throw s;
    295        }
    296      }
    297
    298      public Time getTime(int columnIndex, Calendar cal) throws SQLException
    299      {
    300        String methodCall = "getTime(" + columnIndex + ", " + cal + ")";
    301        try
    302        {
    303          return (Time) reportReturn(methodCall, realResultSet.getTime(columnIndex, cal));
    304        }
    305        catch (SQLException s)
    306        {
    307          reportException(methodCall, s);
    308          throw s;
    309        }
    310      }
    311
    312      public Time getTime(String columnName, Calendar cal) throws SQLException
    313      {
    314        String methodCall = "getTime(" + columnName + ", " + cal + ")";
    315        try
    316        {
    317          return (Time) reportReturn(methodCall, realResultSet.getTime(columnName, cal));
    318        }
    319        catch (SQLException s)
    320        {
    321          reportException(methodCall, s);
    322          throw s;
    323        }
    324      }
    325
    326      public boolean absolute(int row) throws SQLException
    327      {
    328        String methodCall = "absolute(" + row + ")";
    329        try
    330        {
    331          return reportReturn(methodCall, realResultSet.absolute(row));
    332        }
    333        catch (SQLException s)
    334        {
    335          reportException(methodCall, s);
    336          throw s;
    337        }
    338      }
    339
    340      public Timestamp getTimestamp(int columnIndex) throws SQLException
    341      {
    342        String methodCall = "getTimestamp(" + columnIndex + ")";
    343        try
    344        {
    345          return (Timestamp) reportReturn(methodCall, realResultSet.getTimestamp(columnIndex));
    346        }
    347        catch (SQLException s)
    348        {
    349          reportException(methodCall, s);
    350          throw s;
    351        }
    352      }
    353
    354      public Timestamp getTimestamp(String columnName) throws SQLException
    355      {
    356        String methodCall = "getTimestamp(" + columnName + ")";
    357        try
    358        {
    359          return (Timestamp) reportReturn(methodCall, realResultSet.getTimestamp(columnName));
    360        }
    361        catch (SQLException s)
    362        {
    363          reportException(methodCall, s);
    364          throw s;
    365        }
    366
    367      }
    368
    369      public Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException
    370      {
    371        String methodCall = "getTimestamp(" + columnIndex + ", " + cal + ")";
    372        try
    373        {
    374          return (Timestamp) reportReturn(methodCall, realResultSet.getTimestamp(columnIndex, cal));
    375        }
    376        catch (SQLException s)
    377        {
    378          reportException(methodCall, s);
    379          throw s;
    380        }
    381
    382      }
    383
    384      public Timestamp getTimestamp(String columnName, Calendar cal) throws SQLException
    385      {
    386        String methodCall = "getTimestamp(" + columnName + ", " + cal + ")";
    387        try
    388        {
    389          return (Timestamp) reportReturn(methodCall, realResultSet.getTimestamp(columnName, cal));
    390        }
    391        catch (SQLException s)
    392        {
    393          reportException(methodCall, s);
    394          throw s;
    395        }
    396      }
    397
    398      public void moveToInsertRow() throws SQLException
    399      {
    400        String methodCall = "moveToInsertRow()";
    401        try
    402        {
    403          realResultSet.moveToInsertRow();
    404        }
    405        catch (SQLException s)
    406        {
    407          reportException(methodCall, s);
    408          throw s;
    409        }
    410        reportReturn(methodCall);
    411      }
    412
    413      public boolean relative(int rows) throws SQLException
    414      {
    415        String methodCall = "relative(" + rows + ")";
    416        try
    417        {
    418          return reportReturn(methodCall, realResultSet.relative(rows));
    419        }
    420        catch (SQLException s)
    421        {
    422          reportException(methodCall, s);
    423          throw s;
    424        }
    425      }
    426
    427      public boolean previous() throws SQLException
    428      {
    429        String methodCall = "previous()";
    430        try
    431        {
    432          return reportReturn(methodCall, realResultSet.previous());
    433        }
    434        catch (SQLException s)
    435        {
    436          reportException(methodCall, s);
    437          throw s;
    438        }
    439      }
    440
    441      public void moveToCurrentRow() throws SQLException
    442      {
    443        String methodCall = "moveToCurrentRow()";
    444        try
    445        {
    446          realResultSet.moveToCurrentRow();
    447        }
    448        catch (SQLException s)
    449        {
    450          reportException(methodCall, s);
    451          throw s;
    452        }
    453        reportReturn(methodCall);
    454      }
    455
    456      public Ref getRef(int i) throws SQLException
    457      {
    458        String methodCall = "getRef(" + i + ")";
    459        try
    460        {
    461          return (Ref) reportReturn(methodCall, realResultSet.getRef(i));
    462        }
    463        catch (SQLException s)
    464        {
    465          reportException(methodCall, s);
    466          throw s;
    467        }
    468      }
    469
    470      public void updateRef(int columnIndex, Ref x) throws SQLException
    471      {
    472        String methodCall = "updateRef(" + columnIndex + ", " + x + ")";
    473        try
    474        {
    475          realResultSet.updateRef(columnIndex, x);
    476        }
    477        catch (SQLException s)
    478        {
    479          reportException(methodCall, s);
    480          throw s;
    481        }
    482        reportReturn(methodCall);
    483      }
    484
    485      public Ref getRef(String colName) throws SQLException
    486      {
    487        String methodCall = "getRef(" + colName + ")";
    488        try
    489        {
    490          return (Ref) reportReturn(methodCall, realResultSet.getRef(colName));
    491        }
    492        catch (SQLException s)
    493        {
    494          reportException(methodCall, s);
    495          throw s;
    496        }
    497      }
    498
    499      public void updateRef(String columnName, Ref x) throws SQLException
    500      {
    501        String methodCall = "updateRef(" + columnName + ", " + x + ")";
    502        try
    503        {
    504          realResultSet.updateRef(columnName, x);
    505        }
    506        catch (SQLException s)
    507        {
    508          reportException(methodCall, s);
    509          throw s;
    510        }
    511        reportReturn(methodCall);
    512      }
    513
    514      public Blob getBlob(int i) throws SQLException
    515      {
    516        String methodCall = "getBlob(" + i + ")";
    517        try
    518        {
    519          return (Blob) reportReturn(methodCall, realResultSet.getBlob(i));
    520        }
    521        catch (SQLException s)
    522        {
    523          reportException(methodCall, s);
    524          throw s;
    525        }
    526      }
    527
    528      public void updateBlob(int columnIndex, Blob x) throws SQLException
    529      {
    530        String methodCall = "updateBlob(" + columnIndex + ", " + x + ")";
    531        try
    532        {
    533          realResultSet.updateBlob(columnIndex, x);
    534        }
    535        catch (SQLException s)
    536        {
    537          reportException(methodCall, s);
    538          throw s;
    539        }
    540        reportReturn(methodCall);
    541      }
    542
    543      public Blob getBlob(String colName) throws SQLException
    544      {
    545        String methodCall = "getBlob(" + colName + ")";
    546        try
    547        {
    548          return (Blob) reportReturn(methodCall, realResultSet.getBlob(colName));
    549        }
    550        catch (SQLException s)
    551        {
    552          reportException(methodCall, s);
    553          throw s;
    554        }
    555      }
    556
    557      public void updateBlob(String columnName, Blob x) throws SQLException
    558      {
    559        String methodCall = "updateBlob(" + columnName + ", " + x + ")";
    560        try
    561        {
    562          realResultSet.updateBlob(columnName, x);
    563        }
    564        catch (SQLException s)
    565        {
    566          reportException(methodCall, s);
    567          throw s;
    568        }
    569        reportReturn(methodCall);
    570      }
    571
    572      public Clob getClob(int i) throws SQLException
    573      {
    574        String methodCall = "getClob(" + i + ")";
    575        try
    576        {
    577          return (Clob) reportReturn(methodCall, realResultSet.getClob(i));
    578        }
    579        catch (SQLException s)
    580        {
    581          reportException(methodCall, s);
    582          throw s;
    583        }
    584      }
    585
    586      public void updateClob(int columnIndex, Clob x) throws SQLException
    587      {
    588        String methodCall = "updateClob(" + columnIndex + ", " + x + ")";
    589        try
    590        {
    591          realResultSet.updateClob(columnIndex, x);
    592        }
    593        catch (SQLException s)
    594        {
    595          reportException(methodCall, s);
    596          throw s;
    597        }
    598        reportReturn(methodCall);
    599      }
    600
    601      public Clob getClob(String colName) throws SQLException
    602      {
    603        String methodCall = "getClob(" + colName + ")";
    604        try
    605        {
    606          return (Clob) reportReturn(methodCall, realResultSet.getClob(colName));
    607        }
    608        catch (SQLException s)
    609        {
    610          reportException(methodCall, s);
    611          throw s;
    612        }
    613      }
    614
    615      public void updateClob(String columnName, Clob x) throws SQLException
    616      {
    617        String methodCall = "updateClob(" + columnName + ", " + x + ")";
    618        try
    619        {
    620          realResultSet.updateClob(columnName, x);
    621        }
    622        catch (SQLException s)
    623        {
    624          reportException(methodCall, s);
    625          throw s;
    626        }
    627        reportReturn(methodCall);
    628      }
    629
    630      public boolean getBoolean(int columnIndex) throws SQLException
    631      {
    632        String methodCall = "getBoolean(" + columnIndex + ")";
    633        try
    634        {
    635          return reportReturn(methodCall, realResultSet.getBoolean(columnIndex));
    636        }
    637        catch (SQLException s)
    638        {
    639          reportException(methodCall, s);
    640          throw s;
    641        }
    642      }
    643
    644      public boolean getBoolean(String columnName) throws SQLException
    645      {
    646        String methodCall = "getBoolean(" + columnName + ")";
    647        try
    648        {
    649          return reportReturn(methodCall, realResultSet.getBoolean(columnName));
    650        }
    651        catch (SQLException s)
    652        {
    653          reportException(methodCall, s);
    654          throw s;
    655        }
    656      }
    657
    658      public Array getArray(int i) throws SQLException
    659      {
    660        String methodCall = "getArray(" + i + ")";
    661        try
    662        {
    663          return (Array) reportReturn(methodCall, realResultSet.getArray(i));
    664        }
    665        catch (SQLException s)
    666        {
    667          reportException(methodCall, s);
    668          throw s;
    669        }
    670      }
    671
    672      public void updateArray(int columnIndex, Array x) throws SQLException
    673      {
    674        String methodCall = "updateArray(" + columnIndex + ", " + x + ")";
    675        try
    676        {
    677          realResultSet.updateArray(columnIndex, x);
    678        }
    679        catch (SQLException s)
    680        {
    681          reportException(methodCall, s);
    682          throw s;
    683        }
    684        reportReturn(methodCall);
    685      }
    686
    687      public Array getArray(String colName) throws SQLException
    688      {
    689        String methodCall = "getArray(" + colName + ")";
    690        try
    691        {
    692          return (Array) reportReturn(methodCall, realResultSet.getArray(colName));
    693        }
    694        catch (SQLException s)
    695        {
    696          reportException(methodCall, s);
    697          throw s;
    698        }
    699      }
    700
    701      public void updateArray(String columnName, Array x) throws SQLException
    702      {
    703        String methodCall = "updateArray(" + columnName + ", " + x + ")";
    704        try
    705        {
    706          realResultSet.updateArray(columnName, x);
    707        }
    708        catch (SQLException s)
    709        {
    710          reportException(methodCall, s);
    711          throw s;
    712        }
    713        reportReturn(methodCall);
    714      }
    715
    716      public RowId getRowId(int columnIndex) throws SQLException {
    717        String methodCall = "getRowId(" + columnIndex + ")";
    718        try
    719        {
    720          return (RowId) reportReturn(methodCall, realResultSet.getRowId(columnIndex));
    721        }
    722        catch (SQLException s)
    723        {
    724          reportException(methodCall, s);
    725          throw s;
    726        }
    727      }
    728
    729      public RowId getRowId(String columnLabel) throws SQLException {
    730        String methodCall = "getRowId(" + columnLabel + ")";
    731        try
    732        {
    733          return (RowId) reportReturn(methodCall, realResultSet.getRowId(columnLabel));
    734        }
    735        catch (SQLException s)
    736        {
    737          reportException(methodCall, s);
    738          throw s;
    739        }
    740      }
    741
    742      public void updateRowId(int columnIndex, RowId x) throws SQLException {
    743        String methodCall = "updateRowId(" + columnIndex + ", " + x + ")";
    744        try
    745        {
    746          realResultSet.updateRowId(columnIndex, x);
    747        }
    748        catch (SQLException s)
    749        {
    750          reportException(methodCall, s);
    751          throw s;
    752        }
    753        reportReturn(methodCall);
    754      }
    755
    756      public void updateRowId(String columnLabel, RowId x) throws SQLException {
    757        String methodCall = "updateRowId(" + columnLabel + ", " + x + ")";
    758        try
    759        {
    760          realResultSet.updateRowId(columnLabel, x);
    761        }
    762        catch (SQLException s)
    763        {
    764          reportException(methodCall, s);
    765          throw s;
    766        }
    767        reportReturn(methodCall);
    768      }
    769
    770      public int getHoldability() throws SQLException {
    771        String methodCall = "getHoldability()";
    772        try
    773        {
    774          return reportReturn(methodCall, realResultSet.getHoldability());
    775        }
    776        catch (SQLException s)
    777        {
    778          reportException(methodCall, s);
    779          throw s;
    780        }
    781      }
    782
    783      public boolean isClosed() throws SQLException {
    784        String methodCall = "isClosed()";
    785        try
    786        {
    787          return reportReturn(methodCall, realResultSet.isClosed());
    788        }
    789        catch (SQLException s)
    790        {
    791          reportException(methodCall, s);
    792          throw s;
    793        }
    794      }
    795
    796      public void updateNString(int columnIndex, String nString) throws SQLException {
    797        String methodCall = "updateNString(" + columnIndex + ", " + nString + ")";
    798        try
    799        {
    800          realResultSet.updateNString(columnIndex, nString);
    801        }
    802        catch (SQLException s)
    803        {
    804          reportException(methodCall, s);
    805          throw s;
    806        }
    807        reportReturn(methodCall);
    808      }
    809
    810      public void updateNString(String columnLabel, String nString) throws SQLException {
    811        String methodCall = "updateNString(" + columnLabel + ", " + nString + ")";
    812        try
    813        {
    814          realResultSet.updateNString(columnLabel, nString);
    815        }
    816        catch (SQLException s)
    817        {
    818          reportException(methodCall, s);
    819          throw s;
    820        }
    821        reportReturn(methodCall);
    822      }
    823
    824      public void updateNClob(int columnIndex, NClob nClob) throws SQLException {
    825        String methodCall = "updateNClob(" + columnIndex + ", " + nClob + ")";
    826        try
    827        {
    828          realResultSet.updateNClob(columnIndex, nClob);
    829        }
    830        catch (SQLException s)
    831        {
    832          reportException(methodCall, s);
    833          throw s;
    834        }
    835        reportReturn(methodCall);
    836      }
    837
    838      public void updateNClob(String columnLabel, NClob nClob) throws SQLException {
    839        String methodCall = "updateNClob(" + columnLabel + ", " + nClob + ")";
    840        try
    841        {
    842          realResultSet.updateNClob(columnLabel, nClob);
    843        }
    844        catch (SQLException s)
    845        {
    846          reportException(methodCall, s);
    847          throw s;
    848        }
    849        reportReturn(methodCall);
    850      }
    851
    852      public NClob getNClob(int columnIndex) throws SQLException {
    853        String methodCall = "getNClob(" + columnIndex + ")";
    854        try
    855        {
    856          return (NClob) reportReturn(methodCall, realResultSet.getNClob(columnIndex));
    857        }
    858        catch (SQLException s)
    859        {
    860          reportException(methodCall, s);
    861          throw s;
    862        }
    863      }
    864
    865      public NClob getNClob(String columnLabel) throws SQLException {
    866        String methodCall = "getNClob(" + columnLabel + ")";
    867        try
    868        {
    869          return (NClob) reportReturn(methodCall, realResultSet.getNClob(columnLabel));
    870        }
    871        catch (SQLException s)
    872        {
    873          reportException(methodCall, s);
    874          throw s;
    875        }
    876      }
    877
    878      public SQLXML getSQLXML(int columnIndex) throws SQLException {
    879        String methodCall = "getSQLXML(" + columnIndex + ")";
    880        try
    881        {
    882          return (SQLXML) reportReturn(methodCall, realResultSet.getSQLXML(columnIndex));
    883        }
    884        catch (SQLException s)
    885        {
    886          reportException(methodCall, s);
    887          throw s;
    888        }
    889      }
    890
    891      public SQLXML getSQLXML(String columnLabel) throws SQLException {
    892        String methodCall = "getSQLXML(" + columnLabel + ")";
    893        try
    894        {
    895          return (SQLXML) reportReturn(methodCall, realResultSet.getSQLXML(columnLabel));
    896        }
    897        catch (SQLException s)
    898        {
    899          reportException(methodCall, s);
    900          throw s;
    901        }
    902      }
    903
    904      public void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException {
    905        String methodCall = "updateSQLXML(" + columnIndex + ", " + xmlObject + ")";
    906        try
    907        {
    908          realResultSet.updateSQLXML(columnIndex, xmlObject);
    909        }
    910        catch (SQLException s)
    911        {
    912          reportException(methodCall, s);
    913          throw s;
    914        }
    915        reportReturn(methodCall);
    916      }
    917
    918      public void updateSQLXML(String columnLabel, SQLXML xmlObject) throws SQLException {
    919        String methodCall = "updateSQLXML(" + columnLabel + ", " + xmlObject + ")";
    920        try
    921        {
    922          realResultSet.updateSQLXML(columnLabel, xmlObject);
    923        }
    924        catch (SQLException s)
    925        {
    926          reportException(methodCall, s);
    927          throw s;
    928        }
    929        reportReturn(methodCall);
    930      }
    931
    932      public String getNString(int columnIndex) throws SQLException {
    933        String methodCall = "getNString(" + columnIndex + ")";
    934        try
    935        {
    936          return (String) reportReturn(methodCall, realResultSet.getNString(columnIndex));
    937        }
    938        catch (SQLException s)
    939        {
    940          reportException(methodCall, s);
    941          throw s;
    942        }
    943      }
    944
    945      public String getNString(String columnLabel) throws SQLException {
    946        String methodCall = "getNString(" + columnLabel + ")";
    947        try
    948        {
    949          return (String) reportReturn(methodCall, realResultSet.getNString(columnLabel));
    950        }
    951        catch (SQLException s)
    952        {
    953          reportException(methodCall, s);
    954          throw s;
    955        }
    956      }
    957
    958      public Reader getNCharacterStream(int columnIndex) throws SQLException {
    959        String methodCall = "getNCharacterStream(" + columnIndex + ")";
    960        try
    961        {
    962          return (Reader) reportReturn(methodCall, realResultSet.getNCharacterStream(columnIndex));
    963        }
    964        catch (SQLException s)
    965        {
    966          reportException(methodCall, s);
    967          throw s;
    968        }
    969      }
    970
    971      public Reader getNCharacterStream(String columnLabel) throws SQLException {
    972        String methodCall = "getNCharacterStream(" + columnLabel + ")";
    973        try
    974        {
    975          return (Reader) reportReturn(methodCall, realResultSet.getNCharacterStream(columnLabel));
    976        }
    977        catch (SQLException s)
    978        {
    979          reportException(methodCall, s);
    980          throw s;
    981        }
    982      }
    983
    984      public void updateNCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
    985        String methodCall = "updateNCharacterStream(" + columnIndex + ", " + x + ", " + length + ")";
    986        try
    987        {
    988          realResultSet.updateNCharacterStream(columnIndex, x, length);
    989        }
    990        catch (SQLException s)
    991        {
    992          reportException(methodCall, s);
    993          throw s;
    994        }
    995        reportReturn(methodCall);
    996      }
    997
    998      public void updateNCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
    999        String methodCall = "updateNCharacterStream(" + columnLabel + ", " + reader + ", " + length + ")";
    1000        try
    1001        {
    1002          realResultSet.updateNCharacterStream(columnLabel, reader, length);
    1003        }
    1004        catch (SQLException s)
    1005        {
    1006          reportException(methodCall, s);
    1007          throw s;
    1008        }
    1009        reportReturn(methodCall);
    1010      }
    1011
    1012      public void updateAsciiStream(int columnIndex, InputStream x, long length) throws SQLException {
    1013        String methodCall = "updateAsciiStream(" + columnIndex + ", " + x + ", " + length + ")";
    1014        try
    1015        {
    1016          realResultSet.updateAsciiStream(columnIndex, x, length);
    1017        }
    1018        catch (SQLException s)
    1019        {
    1020          reportException(methodCall, s);
    1021          throw s;
    1022        }
    1023        reportReturn(methodCall);
    1024      }
    1025
    1026      public void updateBinaryStream(int columnIndex, InputStream x, long length) throws SQLException {
    1027        String methodCall = "updateBinaryStream(" + columnIndex + ", " + x + ", " + length + ")";
    1028        try
    1029        {
    1030          realResultSet.updateBinaryStream(columnIndex, x, length);
    1031        }
    1032        catch (SQLException s)
    1033        {
    1034          reportException(methodCall, s);
    1035          throw s;
    1036        }
    1037        reportReturn(methodCall);
    1038      }
    1039
    1040      public void updateCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
    1041        String methodCall = "updateCharacterStream(" + columnIndex + ", " + x + ", " + length + ")";
    1042        try
    1043        {
    1044          realResultSet.updateCharacterStream(columnIndex, x, length);
    1045        }
    1046        catch (SQLException s)
    1047        {
    1048          reportException(methodCall, s);
    1049          throw s;
    1050        }
    1051        reportReturn(methodCall);
    1052      }
    1053
    1054      public void updateAsciiStream(String columnLabel, InputStream x, long length) throws SQLException {
    1055        String methodCall = "updateAsciiStream(" + columnLabel + ", " + x + ", " + length + ")";
    1056        try
    1057        {
    1058          realResultSet.updateAsciiStream(columnLabel, x, length);
    1059        }
    1060        catch (SQLException s)
    1061        {
    1062          reportException(methodCall, s);
    1063          throw s;
    1064        }
    1065        reportReturn(methodCall);
    1066      }
    1067
    1068      public void updateBinaryStream(String columnLabel, InputStream x, long length) throws SQLException {
    1069        String methodCall = "updateBinaryStream(" + columnLabel + ", " + x + ", " + length + ")";
    1070        try
    1071        {
    1072          realResultSet.updateBinaryStream(columnLabel, x, length);
    1073        }
    1074        catch (SQLException s)
    1075        {
    1076          reportException(methodCall, s);
    1077          throw s;
    1078        }
    1079        reportReturn(methodCall);
    1080      }
    1081
    1082      public void updateCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
    1083        String methodCall = "updateCharacterStream(" + columnLabel + ", " + reader + ", " + length + ")";
    1084        try
    1085        {
    1086          realResultSet.updateCharacterStream(columnLabel, reader, length);
    1087        }
    1088        catch (SQLException s)
    1089        {
    1090          reportException(methodCall, s);
    1091          throw s;
    1092        }
    1093        reportReturn(methodCall);
    1094      }
    1095
    1096      public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException {
    1097        String methodCall = "updateBlob(" + columnIndex + ", " + inputStream + ", " + length + ")";
    1098        try
    1099        {
    1100          realResultSet.updateBlob(columnIndex, inputStream, length);
    1101        }
    1102        catch (SQLException s)
    1103        {
    1104          reportException(methodCall, s);
    1105          throw s;
    1106        }
    1107        reportReturn(methodCall);
    1108      }
    1109
    1110      public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException {
    1111        String methodCall = "updateBlob(" + columnLabel + ", " + inputStream + ", " + length + ")";
    1112        try
    1113        {
    1114          realResultSet.updateBlob(columnLabel, inputStream, length);
    1115        }
    1116        catch (SQLException s)
    1117        {
    1118          reportException(methodCall, s);
    1119          throw s;
    1120        }
    1121        reportReturn(methodCall);
    1122      }
    1123
    1124      public void updateClob(int columnIndex, Reader reader, long length) throws SQLException {
    1125        String methodCall = "updateClob(" + columnIndex + ", " + reader + ", " + length + ")";
    1126        try
    1127        {
    1128          realResultSet.updateClob(columnIndex, reader, length);
    1129        }
    1130        catch (SQLException s)
    1131        {
    1132          reportException(methodCall, s);
    1133          throw s;
    1134        }
    1135        reportReturn(methodCall);
    1136      }
    1137
    1138      public void updateClob(String columnLabel, Reader reader, long length) throws SQLException {
    1139        String methodCall = "updateClob(" + columnLabel + ", " + reader + ", " + length + ")";
    1140        try
    1141        {
    1142          realResultSet.updateClob(columnLabel, reader, length);
    1143        }
    1144        catch (SQLException s)
    1145        {
    1146          reportException(methodCall, s);
    1147          throw s;
    1148        }
    1149        reportReturn(methodCall);
    1150      }
    1151
    1152      public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException {
    1153        String methodCall = "updateNClob(" + columnIndex + ", " + reader + ", " + length + ")";
    1154        try
    1155        {
    1156          realResultSet.updateNClob(columnIndex, reader, length);
    1157        }
    1158        catch (SQLException s)
    1159        {
    1160          reportException(methodCall, s);
    1161          throw s;
    1162        }
    1163        reportReturn(methodCall);
    1164      }
    1165
    1166      public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException {
    1167        String methodCall = "updateNClob(" + columnLabel + ", " + reader + ", " + length + ")";
    1168        try
    1169        {
    1170          realResultSet.updateNClob(columnLabel, reader, length);
    1171        }
    1172        catch (SQLException s)
    1173        {
    1174          reportException(methodCall, s);
    1175          throw s;
    1176        }
    1177        reportReturn(methodCall);
    1178      }
    1179
    1180      public void updateNCharacterStream(int columnIndex, Reader reader) throws SQLException {
    1181        String methodCall = "updateNCharacterStream(" + columnIndex + ", " + reader + ")";
    1182        try
    1183        {
    1184          realResultSet.updateNCharacterStream(columnIndex, reader);
    1185        }
    1186        catch (SQLException s)
    1187        {
    1188          reportException(methodCall, s);
    1189          throw s;
    1190        }
    1191        reportReturn(methodCall);
    1192      }
    1193
    1194      public void updateNCharacterStream(String columnLabel, Reader reader) throws SQLException {
    1195        String methodCall = "updateNCharacterStream(" + columnLabel + ", " + reader + ")";
    1196        try
    1197        {
    1198          realResultSet.updateNCharacterStream(columnLabel, reader);
    1199        }
    1200        catch (SQLException s)
    1201        {
    1202          reportException(methodCall, s);
    1203          throw s;
    1204        }
    1205        reportReturn(methodCall);
    1206      }
    1207
    1208      public void updateAsciiStream(int columnIndex, InputStream x) throws SQLException {
    1209        String methodCall = "updateAsciiStream(" + columnIndex + ", " + x + ")";
    1210        try
    1211        {
    1212          realResultSet.updateAsciiStream(columnIndex, x);
    1213        }
    1214        catch (SQLException s)
    1215        {
    1216          reportException(methodCall, s);
    1217          throw s;
    1218        }
    1219        reportReturn(methodCall);
    1220      }
    1221
    1222      public void updateBinaryStream(int columnIndex, InputStream x) throws SQLException {
    1223        String methodCall = "updateBinaryStream(" + columnIndex + ", " + x + ")";
    1224        try
    1225        {
    1226          realResultSet.updateBinaryStream(columnIndex, x);
    1227        }
    1228        catch (SQLException s)
    1229        {
    1230          reportException(methodCall, s);
    1231          throw s;
    1232        }
    1233        reportReturn(methodCall);
    1234      }
    1235
    1236      public void updateCharacterStream(int columnIndex, Reader x) throws SQLException {
    1237        String methodCall = "updateCharacterStream(" + columnIndex + ", " + x + ")";
    1238        try
    1239        {
    1240          realResultSet.updateCharacterStream(columnIndex, x);
    1241        }
    1242        catch (SQLException s)
    1243        {
    1244          reportException(methodCall, s);
    1245          throw s;
    1246        }
    1247        reportReturn(methodCall);
    1248      }
    1249
    1250      public void updateAsciiStream(String columnLabel, InputStream x) throws SQLException {
    1251        String methodCall = "updateAsciiStream(" + columnLabel + ", " + x + ")";
    1252        try
    1253        {
    1254          realResultSet.updateAsciiStream(columnLabel, x);
    1255        }
    1256        catch (SQLException s)
    1257        {
    1258          reportException(methodCall, s);
    1259          throw s;
    1260        }
    1261        reportReturn(methodCall);
    1262      }
    1263
    1264      public void updateBinaryStream(String columnLabel, InputStream x) throws SQLException {
    1265        String methodCall = "updateBinaryStream(" + columnLabel + ", " + x + ")";
    1266        try
    1267        {
    1268          realResultSet.updateBinaryStream(columnLabel, x);
    1269        }
    1270        catch (SQLException s)
    1271        {
    1272          reportException(methodCall, s);
    1273          throw s;
    1274        }
    1275        reportReturn(methodCall);
    1276      }
    1277
    1278      public void updateCharacterStream(String columnLabel, Reader reader) throws SQLException {
    1279        String methodCall = "updateCharacterStream(" + columnLabel + ", " + reader + ")";
    1280        try
    1281        {
    1282          realResultSet.updateCharacterStream(columnLabel, reader);
    1283        }
    1284        catch (SQLException s)
    1285        {
    1286          reportException(methodCall, s);
    1287          throw s;
    1288        }
    1289        reportReturn(methodCall);
    1290      }
    1291
    1292      public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException {
    1293        String methodCall = "updateBlob(" + columnIndex + ", " + inputStream + ")";
    1294        try
    1295        {
    1296          realResultSet.updateBlob(columnIndex, inputStream);
    1297        }
    1298        catch (SQLException s)
    1299        {
    1300          reportException(methodCall, s);
    1301          throw s;
    1302        }
    1303        reportReturn(methodCall);
    1304      }
    1305
    1306      public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException {
    1307        String methodCall = "updateBlob(" + columnLabel + ", " + inputStream + ")";
    1308        try
    1309        {
    1310          realResultSet.updateBlob(columnLabel, inputStream);
    1311        }
    1312        catch (SQLException s)
    1313        {
    1314          reportException(methodCall, s);
    1315          throw s;
    1316        }
    1317        reportReturn(methodCall);
    1318      }
    1319
    1320      public void updateClob(int columnIndex, Reader reader) throws SQLException {
    1321        String methodCall = "updateClob(" + columnIndex + ", " + reader + ")";
    1322        try
    1323        {
    1324          realResultSet.updateClob(columnIndex, reader);
    1325        }
    1326        catch (SQLException s)
    1327        {
    1328          reportException(methodCall, s);
    1329          throw s;
    1330        }
    1331        reportReturn(methodCall);
    1332      }
    1333
    1334      public void updateClob(String columnLabel, Reader reader) throws SQLException {
    1335        String methodCall = "updateClob(" + columnLabel + ", " + reader + ")";
    1336        try
    1337        {
    1338          realResultSet.updateClob(columnLabel, reader);
    1339        }
    1340        catch (SQLException s)
    1341        {
    1342          reportException(methodCall, s);
    1343          throw s;
    1344        }
    1345        reportReturn(methodCall);
    1346      }
    1347
    1348      public void updateNClob(int columnIndex, Reader reader) throws SQLException {
    1349        String methodCall = "updateNClob(" + columnIndex + ", " + reader + ")";
    1350        try
    1351        {
    1352          realResultSet.updateNClob(columnIndex, reader);
    1353        }
    1354        catch (SQLException s)
    1355        {
    1356          reportException(methodCall, s);
    1357          throw s;
    1358        }
    1359        reportReturn(methodCall);
    1360      }
    1361
    1362      public void updateNClob(String columnLabel, Reader reader) throws SQLException {
    1363        String methodCall = "updateNClob(" + columnLabel + ", " + reader + ")";
    1364        try
    1365        {
    1366          realResultSet.updateNClob(columnLabel, reader);
    1367        }
    1368        catch (SQLException s)
    1369        {
    1370          reportException(methodCall, s);
    1371          throw s;
    1372        }
    1373        reportReturn(methodCall);
    1374      }
    1375
    1376      public boolean isBeforeFirst() throws SQLException
    1377      {
    1378        String methodCall = "isBeforeFirst()";
    1379        try
    1380        {
    1381          return reportReturn(methodCall, realResultSet.isBeforeFirst());
    1382        }
    1383        catch (SQLException s)
    1384        {
    1385          reportException(methodCall, s);
    1386          throw s;
    1387        }
    1388      }
    1389
    1390      public short getShort(int columnIndex) throws SQLException
    1391      {
    1392        String methodCall = "getShort(" + columnIndex + ")";
    1393        try
    1394        {
    1395          return reportReturn(methodCall, realResultSet.getShort(columnIndex));
    1396        }
    1397        catch (SQLException s)
    1398        {
    1399          reportException(methodCall, s);
    1400          throw s;
    1401        }
    1402      }
    1403
    1404      public short getShort(String columnName) throws SQLException
    1405      {
    1406        String methodCall = "getShort(" + columnName + ")";
    1407        try
    1408        {
    1409          return reportReturn(methodCall, realResultSet.getShort(columnName));
    1410        }
    1411        catch (SQLException s)
    1412        {
    1413          reportException(methodCall, s);
    1414          throw s;
    1415        }
    1416      }
    1417
    1418      public int getInt(int columnIndex) throws SQLException
    1419      {
    1420        String methodCall = "getInt(" + columnIndex + ")";
    1421        try
    1422        {
    1423          return reportReturn(methodCall, realResultSet.getInt(columnIndex));
    1424        }
    1425        catch (SQLException s)
    1426        {
    1427          reportException(methodCall, s);
    1428          throw s;
    1429        }
    1430      }
    1431
    1432      public int getInt(String columnName) throws SQLException
    1433      {
    1434        String methodCall = "getInt(" + columnName + ")";
    1435        try
    1436        {
    1437          return reportReturn(methodCall, realResultSet.getInt(columnName));
    1438        }
    1439        catch (SQLException s)
    1440        {
    1441          reportException(methodCall, s);
    1442          throw s;
    1443        }
    1444      }
    1445
    1446      public void close() throws SQLException
    1447      {
    1448        String methodCall = "close()";
    1449        try
    1450        {
    1451          realResultSet.close();
    1452        }
    1453        catch (SQLException s)
    1454        {
    1455          reportException(methodCall, s);
    1456          throw s;
    1457        }
    1458        reportReturn(methodCall);
    1459      }
    1460
    1461      public ResultSetMetaData getMetaData() throws SQLException
    1462      {
    1463        String methodCall = "getMetaData()";
    1464        try
    1465        {
    1466          return (ResultSetMetaData) reportReturn(methodCall, realResultSet.getMetaData());
    1467        }
    1468        catch (SQLException s)
    1469        {
    1470          reportException(methodCall, s);
    1471          throw s;
    1472        }
    1473      }
    1474
    1475      public int getType() throws SQLException
    1476      {
    1477        String methodCall = "getType()";
    1478        try
    1479        {
    1480          return reportReturn(methodCall, realResultSet.getType());
    1481        }
    1482        catch (SQLException s)
    1483        {
    1484          reportException(methodCall, s);
    1485          throw s;
    1486        }
    1487      }
    1488
    1489      public double getDouble(int columnIndex) throws SQLException
    1490      {
    1491        String methodCall = "getDouble(" + columnIndex + ")";
    1492        try
    1493        {
    1494          return reportReturn(methodCall, realResultSet.getDouble(columnIndex));
    1495        }
    1496        catch (SQLException s)
    1497        {
    1498          reportException(methodCall, s);
    1499          throw s;
    1500        }
    1501      }
    1502
    1503      public double getDouble(String columnName) throws SQLException
    1504      {
    1505        String methodCall = "getDouble(" + columnName + ")";
    1506        try
    1507        {
    1508          return reportReturn(methodCall, realResultSet.getDouble(columnName));
    1509        }
    1510        catch (SQLException s)
    1511        {
    1512          reportException(methodCall, s);
    1513          throw s;
    1514        }
    1515      }
    1516
    1517      public void deleteRow() throws SQLException
    1518      {
    1519        String methodCall = "deleteRow()";
    1520        try
    1521        {
    1522          realResultSet.deleteRow();
    1523        }
    1524        catch (SQLException s)
    1525        {
    1526          reportException(methodCall, s);
    1527          throw s;
    1528        }
    1529        reportReturn(methodCall);
    1530      }
    1531
    1532      public int getConcurrency() throws SQLException
    1533      {
    1534        String methodCall = "getConcurrency()";
    1535        try
    1536        {
    1537          return reportReturn(methodCall, realResultSet.getConcurrency());
    1538        }
    1539        catch (SQLException s)
    1540        {
    1541          reportException(methodCall, s);
    1542          throw s;
    1543        }
    1544      }
    1545
    1546      public boolean rowUpdated() throws SQLException
    1547      {
    1548        String methodCall = "rowUpdated()";
    1549        try
    1550        {
    1551          return reportReturn(methodCall, realResultSet.rowUpdated());
    1552        }
    1553        catch (SQLException s)
    1554        {
    1555          reportException(methodCall, s);
    1556          throw s;
    1557        }
    1558      }
    1559
    1560      public Date getDate(int columnIndex) throws SQLException
    1561      {
    1562        String methodCall = "getDate(" + columnIndex + ")";
    1563        try
    1564        {
    1565          return (Date) reportReturn(methodCall, realResultSet.getDate(columnIndex));
    1566        }
    1567        catch (SQLException s)
    1568        {
    1569          reportException(methodCall, s);
    1570          throw s;
    1571        }
    1572      }
    1573
    1574      public Date getDate(String columnName) throws SQLException
    1575      {
    1576        String methodCall = "getDate(" + columnName + ")";
    1577        try
    1578        {
    1579          return (Date) reportReturn(methodCall, realResultSet.getDate(columnName));
    1580        }
    1581        catch (SQLException s)
    1582        {
    1583          reportException(methodCall, s);
    1584          throw s;
    1585        }
    1586      }
    1587
    1588      public Date getDate(int columnIndex, Calendar cal) throws SQLException
    1589      {
    1590        String methodCall = "getDate(" + columnIndex + ", " + cal + ")";
    1591        try
    1592        {
    1593          return (Date) reportReturn(methodCall, realResultSet.getDate(columnIndex, cal));
    1594        }
    1595        catch (SQLException s)
    1596        {
    1597          reportException(methodCall, s);
    1598          throw s;
    1599        }
    1600
    1601      }
    1602
    1603      public Date getDate(String columnName, Calendar cal) throws SQLException
    1604      {
    1605        String methodCall = "getDate(" + columnName + ", " + cal + ")";
    1606        try
    1607        {
    1608          return (Date) reportReturn(methodCall, realResultSet.getDate(columnName, cal));
    1609        }
    1610        catch (SQLException s)
    1611        {
    1612          reportException(methodCall, s);
    1613          throw s;
    1614        }
    1615      }
    1616
    1617      public boolean last() throws SQLException
    1618      {
    1619        String methodCall = "last()";
    1620        try
    1621        {
    1622          return reportReturn(methodCall, realResultSet.last());
    1623        }
    1624        catch (SQLException s)
    1625        {
    1626          reportException(methodCall, s);
    1627          throw s;
    1628        }
    1629      }
    1630
    1631      public boolean rowInserted() throws SQLException
    1632      {
    1633        String methodCall = "rowInserted()";
    1634        try
    1635        {
    1636          return reportReturn(methodCall, realResultSet.rowInserted());
    1637        }
    1638        catch (SQLException s)
    1639        {
    1640          reportException(methodCall, s);
    1641          throw s;
    1642        }
    1643      }
    1644
    1645      public boolean rowDeleted() throws SQLException
    1646      {
    1647        String methodCall = "rowDeleted()";
    1648        try
    1649        {
    1650          return reportReturn(methodCall, realResultSet.rowDeleted());
    1651        }
    1652        catch (SQLException s)
    1653        {
    1654          reportException(methodCall, s);
    1655          throw s;
    1656        }
    1657      }
    1658
    1659      public void updateNull(int columnIndex) throws SQLException
    1660      {
    1661        String methodCall = "updateNull(" + columnIndex + ")";
    1662        try
    1663        {
    1664          realResultSet.updateNull(columnIndex);
    1665        }
    1666        catch (SQLException s)
    1667        {
    1668          reportException(methodCall, s);
    1669          throw s;
    1670        }
    1671        reportReturn(methodCall);
    1672      }
    1673
    1674      public void updateNull(String columnName) throws SQLException
    1675      {
    1676        String methodCall = "updateNull(" + columnName + ")";
    1677        try
    1678        {
    1679          realResultSet.updateNull(columnName);
    1680        }
    1681        catch (SQLException s)
    1682        {
    1683          reportException(methodCall, s);
    1684          throw s;
    1685        }
    1686        reportReturn(methodCall);
    1687      }
    1688
    1689      public void updateShort(int columnIndex, short x) throws SQLException
    1690      {
    1691        String methodCall = "updateShort(" + columnIndex + ", " + x + ")";
    1692        try
    1693        {
    1694          realResultSet.updateShort(columnIndex, x);
    1695        }
    1696        catch (SQLException s)
    1697        {
    1698          reportException(methodCall, s);
    1699          throw s;
    1700        }
    1701        reportReturn(methodCall);
    1702      }
    1703
    1704      public void updateShort(String columnName, short x) throws SQLException
    1705      {
    1706        String methodCall = "updateShort(" + columnName + ", " + x + ")";
    1707        try
    1708        {
    1709          realResultSet.updateShort(columnName, x);
    1710        }
    1711        catch (SQLException s)
    1712        {
    1713          reportException(methodCall, s);
    1714          throw s;
    1715        }
    1716        reportReturn(methodCall);
    1717      }
    1718
    1719      public void updateBoolean(int columnIndex, boolean x) throws SQLException
    1720      {
    1721        String methodCall = "updateBoolean(" + columnIndex + ", " + x + ")";
    1722        try
    1723        {
    1724          realResultSet.updateBoolean(columnIndex, x);
    1725        }
    1726        catch (SQLException s)
    1727        {
    1728          reportException(methodCall, s);
    1729          throw s;
    1730        }
    1731        reportReturn(methodCall);
    1732      }
    1733
    1734      public void updateBoolean(String columnName, boolean x) throws SQLException
    1735      {
    1736        String methodCall = "updateBoolean(" + columnName + ", " + x + ")";
    1737        try
    1738        {
    1739          realResultSet.updateBoolean(columnName, x);
    1740        }
    1741        catch (SQLException s)
    1742        {
    1743          reportException(methodCall, s);
    1744          throw s;
    1745        }
    1746        reportReturn(methodCall);
    1747      }
    1748
    1749      public void updateByte(int columnIndex, byte x) throws SQLException
    1750      {
    1751        String methodCall = "updateByte(" + columnIndex + ", " + x + ")";
    1752        try
    1753        {
    1754          realResultSet.updateByte(columnIndex, x);
    1755        }
    1756        catch (SQLException s)
    1757        {
    1758          reportException(methodCall, s);
    1759          throw s;
    1760        }
    1761        reportReturn(methodCall);
    1762      }
    1763
    1764      public void updateByte(String columnName, byte x) throws SQLException
    1765      {
    1766        String methodCall = "updateByte(" + columnName + ", " + x + ")";
    1767        try
    1768        {
    1769          realResultSet.updateByte(columnName, x);
    1770        }
    1771        catch (SQLException s)
    1772        {
    1773          reportException(methodCall, s);
    1774          throw s;
    1775        }
    1776        reportReturn(methodCall);
    1777      }
    1778
    1779      public void updateInt(int columnIndex, int x) throws SQLException
    1780      {
    1781        String methodCall = "updateInt(" + columnIndex + ", " + x + ")";
    1782        try
    1783        {
    1784          realResultSet.updateInt(columnIndex, x);
    1785        }
    1786        catch (SQLException s)
    1787        {
    1788          reportException(methodCall, s);
    1789          throw s;
    1790        }
    1791        reportReturn(methodCall);
    1792      }
    1793
    1794      public void updateInt(String columnName, int x) throws SQLException
    1795      {
    1796        String methodCall = "updateInt(" + columnName + ", " + x + ")";
    1797        try
    1798        {
    1799          realResultSet.updateInt(columnName, x);
    1800        }
    1801        catch (SQLException s)
    1802        {
    1803          reportException(methodCall, s);
    1804          throw s;
    1805        }
    1806        reportReturn(methodCall);
    1807      }
    1808
    1809      public Object getObject(int columnIndex) throws SQLException
    1810      {
    1811        String methodCall = "getObject(" + columnIndex + ")";
    1812        try
    1813        {
    1814          return reportReturn(methodCall, realResultSet.getObject(columnIndex));
    1815        }
    1816        catch (SQLException s)
    1817        {
    1818          reportException(methodCall, s);
    1819          throw s;
    1820        }
    1821      }
    1822
    1823      public Object getObject(String columnName) throws SQLException
    1824      {
    1825        String methodCall = "getObject(" + columnName + ")";
    1826        try
    1827        {
    1828          return reportReturn(methodCall, realResultSet.getObject(columnName));
    1829        }
    1830        catch (SQLException s)
    1831        {
    1832          reportException(methodCall, s);
    1833          throw s;
    1834        }
    1835      }
    1836
    1837      public Object getObject(String colName, Map map) throws SQLException
    1838      {
    1839        String methodCall = "getObject(" + colName + ", " + map + ")";
    1840        try
    1841        {
    1842          return reportReturn(methodCall, realResultSet.getObject(colName, map));
    1843        }
    1844        catch (SQLException s)
    1845        {
    1846          reportException(methodCall, s);
    1847          throw s;
    1848        }
    1849      }
    1850
    1851      public boolean next() throws SQLException
    1852      {
    1853        String methodCall = "next()";
    1854        try
    1855        {
    1856          return reportReturn(methodCall, realResultSet.next());
    1857        }
    1858        catch (SQLException s)
    1859        {
    1860          reportException(methodCall, s);
    1861          throw s;
    1862        }
    1863      }
    1864
    1865      public void updateLong(int columnIndex, long x) throws SQLException
    1866      {
    1867        String methodCall = "updateLong(" + columnIndex + ", " + x + ")";
    1868        try
    1869        {
    1870          realResultSet.updateLong(columnIndex, x);
    1871        }
    1872        catch (SQLException s)
    1873        {
    1874          reportException(methodCall, s);
    1875          throw s;
    1876        }
    1877        reportReturn(methodCall);
    1878      }
    1879
    1880      public void updateLong(String columnName, long x) throws SQLException
    1881      {
    1882        String methodCall = "updateLong(" + columnName + ", " + x + ")";
    1883        try
    1884        {
    1885          realResultSet.updateLong(columnName, x);
    1886        }
    1887        catch (SQLException s)
    1888        {
    1889          reportException(methodCall, s);
    1890          throw s;
    1891        }
    1892        reportReturn(methodCall);
    1893      }
    1894
    1895      public void updateFloat(int columnIndex, float x) throws SQLException
    1896      {
    1897        String methodCall = "updateFloat(" + columnIndex + ", " + x + ")";
    1898        try
    1899        {
    1900          realResultSet.updateFloat(columnIndex, x);
    1901        }
    1902        catch (SQLException s)
    1903        {
    1904          reportException(methodCall, s);
    1905          throw s;
    1906        }
    1907        reportReturn(methodCall);
    1908
    1909      }
    1910
    1911      public void updateFloat(String columnName, float x) throws SQLException
    1912      {
    1913        String methodCall = "updateFloat(" + columnName + ", " + x + ")";
    1914        try
    1915        {
    1916          realResultSet.updateFloat(columnName, x);
    1917        }
    1918        catch (SQLException s)
    1919        {
    1920          reportException(methodCall, s);
    1921          throw s;
    1922        }
    1923        reportReturn(methodCall);
    1924      }
    1925
    1926      public void updateDouble(int columnIndex, double x) throws SQLException
    1927      {
    1928        String methodCall = "updateDouble(" + columnIndex + ", " + x + ")";
    1929        try
    1930        {
    1931          realResultSet.updateDouble(columnIndex, x);
    1932        }
    1933        catch (SQLException s)
    1934        {
    1935          reportException(methodCall, s);
    1936          throw s;
    1937        }
    1938        reportReturn(methodCall);
    1939      }
    1940
    1941      public void updateDouble(String columnName, double x) throws SQLException
    1942      {
    1943        String methodCall = "updateDouble(" + columnName + ", " + x + ")";
    1944        try
    1945        {
    1946          realResultSet.updateDouble(columnName, x);
    1947        }
    1948        catch (SQLException s)
    1949        {
    1950          reportException(methodCall, s);
    1951          throw s;
    1952        }
    1953        reportReturn(methodCall);
    1954      }
    1955
    1956      public Statement getStatement() throws SQLException
    1957      {
    1958        String methodCall = "getStatement()";
    1959        try
    1960        {
    1961          Statement s = realResultSet.getStatement();
    1962          if (s == null)
    1963          {
    1964            return (Statement) reportReturn(methodCall, s);
    1965          }
    1966          else
    1967          {
    1968            //todo: what's going on here?
    1969            return (Statement) reportReturn(methodCall, new StatementSpy(new ConnectionSpy(s.getConnection()), s));
    1970          }
    1971        }
    1972        catch (SQLException s)
    1973        {
    1974          reportException(methodCall, s);
    1975          throw s;
    1976        }
    1977      }
    1978
    1979      public Object getObject(int columnIndex, Map<String, Class<?>> map) throws SQLException
    1980      {
    1981        String methodCall = "getObject(" + columnIndex + ", " + map + ")";
    1982        try
    1983        {
    1984          return reportReturn(methodCall, realResultSet.getObject(columnIndex, map));
    1985        }
    1986        catch (SQLException s)
    1987        {
    1988          reportException(methodCall, s);
    1989          throw s;
    1990        }
    1991      }
    1992
    1993      public void updateString(int columnIndex, String x) throws SQLException
    1994      {
    1995        String methodCall = "updateString(" + columnIndex + ", " + x + ")";
    1996        try
    1997        {
    1998          realResultSet.updateString(columnIndex, x);
    1999        }
    2000        catch (SQLException s)
    2001        {
    2002          reportException(methodCall, s);
    2003          throw s;
    2004        }
    2005        reportReturn(methodCall);
    2006      }
    2007
    2008      public void updateString(String columnName, String x) throws SQLException
    2009      {
    2010        String methodCall = "updateString(" + columnName + ", " + x + ")";
    2011        try
    2012        {
    2013          realResultSet.updateString(columnName, x);
    2014        }
    2015        catch (SQLException s)
    2016        {
    2017          reportException(methodCall, s);
    2018          throw s;
    2019        }
    2020        reportReturn(methodCall);
    2021      }
    2022
    2023      public InputStream getAsciiStream(int columnIndex) throws SQLException
    2024      {
    2025        String methodCall = "getAsciiStream(" + columnIndex + ")";
    2026        try
    2027        {
    2028          return (InputStream) reportReturn(methodCall, realResultSet.getAsciiStream(columnIndex));
    2029        }
    2030        catch (SQLException s)
    2031        {
    2032          reportException(methodCall, s);
    2033          throw s;
    2034        }
    2035      }
    2036
    2037      public InputStream getAsciiStream(String columnName) throws SQLException
    2038      {
    2039        String methodCall = "getAsciiStream(" + columnName + ")";
    2040        try
    2041        {
    2042          return (InputStream) reportReturn(methodCall, realResultSet.getAsciiStream(columnName));
    2043        }
    2044        catch (SQLException s)
    2045        {
    2046          reportException(methodCall, s);
    2047          throw s;
    2048        }
    2049      }
    2050
    2051      public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException
    2052      {
    2053        String methodCall = "updateBigDecimal(" + columnIndex + ", " + x + ")";
    2054        try
    2055        {
    2056          realResultSet.updateBigDecimal(columnIndex, x);
    2057        }
    2058        catch (SQLException s)
    2059        {
    2060          reportException(methodCall, s);
    2061          throw s;
    2062        }
    2063        reportReturn(methodCall);
    2064      }
    2065
    2066      public URL getURL(int columnIndex) throws SQLException
    2067      {
    2068        String methodCall = "getURL(" + columnIndex + ")";
    2069        try
    2070        {
    2071          return (URL) reportReturn(methodCall, realResultSet.getURL(columnIndex));
    2072        }
    2073        catch (SQLException s)
    2074        {
    2075          reportException(methodCall, s);
    2076          throw s;
    2077        }
    2078      }
    2079
    2080      public void updateBigDecimal(String columnName, BigDecimal x) throws SQLException
    2081      {
    2082        String methodCall = "updateBigDecimal(" + columnName + ", " + x + ")";
    2083        try
    2084        {
    2085          realResultSet.updateBigDecimal(columnName, x);
    2086        }
    2087        catch (SQLException s)
    2088        {
    2089          reportException(methodCall, s);
    2090          throw s;
    2091        }
    2092        reportReturn(methodCall);
    2093      }
    2094
    2095      public URL getURL(String columnName) throws SQLException
    2096      {
    2097        String methodCall = "getURL(" + columnName + ")";
    2098        try
    2099        {
    2100          return (URL) reportReturn(methodCall, realResultSet.getURL(columnName));
    2101        }
    2102        catch (SQLException s)
    2103        {
    2104          reportException(methodCall, s);
    2105          throw s;
    2106        }
    2107      }
    2108
    2109      public void updateBytes(int columnIndex, byte[] x) throws SQLException
    2110      {
    2111        // todo: dump array?
    2112        String methodCall = "updateBytes(" + columnIndex + ", " + x + ")";
    2113        try
    2114        {
    2115          realResultSet.updateBytes(columnIndex, x);
    2116        }
    2117        catch (SQLException s)
    2118        {
    2119          reportException(methodCall, s);
    2120          throw s;
    2121        }
    2122        reportReturn(methodCall);
    2123      }
    2124
    2125      public void updateBytes(String columnName, byte[] x) throws SQLException
    2126      {
    2127        // todo: dump array?
    2128        String methodCall = "updateBytes(" + columnName + ", " + x + ")";
    2129        try
    2130        {
    2131          realResultSet.updateBytes(columnName, x);
    2132        }
    2133        catch (SQLException s)
    2134        {
    2135          reportException(methodCall, s);
    2136          throw s;
    2137        }
    2138        reportReturn(methodCall);
    2139      }
    2140
    2141      /**
    2142       * @deprecated
    2143       */
    2144      public InputStream getUnicodeStream(int columnIndex) throws SQLException
    2145      {
    2146        String methodCall = "getUnicodeStream(" + columnIndex + ")";
    2147        try
    2148        {
    2149          return (InputStream) reportReturn(methodCall, realResultSet.getUnicodeStream(columnIndex));
    2150        }
    2151        catch (SQLException s)
    2152        {
    2153          reportException(methodCall, s);
    2154          throw s;
    2155        }
    2156      }
    2157
    2158      /**
    2159       * @deprecated
    2160       */
    2161      public InputStream getUnicodeStream(String columnName) throws SQLException
    2162      {
    2163        String methodCall = "getUnicodeStream(" + columnName + ")";
    2164        try
    2165        {
    2166          return (InputStream) reportReturn(methodCall, realResultSet.getUnicodeStream(columnName));
    2167        }
    2168        catch (SQLException s)
    2169        {
    2170          reportException(methodCall, s);
    2171          throw s;
    2172        }
    2173      }
    2174
    2175      public void updateDate(int columnIndex, Date x) throws SQLException
    2176      {
    2177        String methodCall = "updateDate(" + columnIndex + ", " + x + ")";
    2178        try
    2179        {
    2180          realResultSet.updateDate(columnIndex, x);
    2181        }
    2182        catch (SQLException s)
    2183        {
    2184          reportException(methodCall, s);
    2185          throw s;
    2186        }
    2187      }
    2188
    2189      public void updateDate(String columnName, Date x) throws SQLException
    2190      {
    2191        String methodCall = "updateDate(" + columnName + ", " + x + ")";
    2192        try
    2193        {
    2194          realResultSet.updateDate(columnName, x);
    2195        }
    2196        catch (SQLException s)
    2197        {
    2198          reportException(methodCall, s);
    2199          throw s;
    2200        }
    2201        reportReturn(methodCall);
    2202      }
    2203
    2204      public int getFetchSize() throws SQLException
    2205      {
    2206        String methodCall = "getFetchSize()";
    2207        try
    2208        {
    2209          return reportReturn(methodCall, realResultSet.getFetchSize());
    2210        }
    2211        catch (SQLException s)
    2212        {
    2213          reportException(methodCall, s);
    2214          throw s;
    2215        }
    2216      }
    2217
    2218      public SQLWarning getWarnings() throws SQLException
    2219      {
    2220        String methodCall = "getWarnings()";
    2221        try
    2222        {
    2223          return (SQLWarning) reportReturn(methodCall, realResultSet.getWarnings());
    2224        }
    2225        catch (SQLException s)
    2226        {
    2227          reportException(methodCall, s);
    2228          throw s;
    2229        }
    2230      }
    2231
    2232      public InputStream getBinaryStream(int columnIndex) throws SQLException
    2233      {
    2234        String methodCall = "getBinaryStream(" + columnIndex + ")";
    2235        try
    2236        {
    2237          return (InputStream) reportReturn(methodCall, realResultSet.getBinaryStream(columnIndex));
    2238        }
    2239        catch (SQLException s)
    2240        {
    2241          reportException(methodCall, s);
    2242          throw s;
    2243        }
    2244      }
    2245
    2246      public InputStream getBinaryStream(String columnName) throws SQLException
    2247      {
    2248        String methodCall = "getBinaryStream(" + columnName + ")";
    2249        try
    2250        {
    2251          return (InputStream) reportReturn(methodCall, realResultSet.getBinaryStream(columnName));
    2252        }
    2253        catch (SQLException s)
    2254        {
    2255          reportException(methodCall, s);
    2256          throw s;
    2257        }
    2258      }
    2259
    2260      public void clearWarnings() throws SQLException
    2261      {
    2262        String methodCall = "clearWarnings()";
    2263        try
    2264        {
    2265          realResultSet.clearWarnings();
    2266        }
    2267        catch (SQLException s)
    2268        {
    2269          reportException(methodCall, s);
    2270          throw s;
    2271        }
    2272        reportReturn(methodCall);
    2273      }
    2274
    2275      public void updateTimestamp(int columnIndex, Timestamp x) throws SQLException
    2276      {
    2277        String methodCall = "updateTimestamp(" + columnIndex + ", " + x + ")";
    2278        try
    2279        {
    2280          realResultSet.updateTimestamp(columnIndex, x);
    2281        }
    2282        catch (SQLException s)
    2283        {
    2284          reportException(methodCall, s);
    2285          throw s;
    2286        }
    2287        reportReturn(methodCall);
    2288      }
    2289
    2290      public void updateTimestamp(String columnName, Timestamp x) throws SQLException
    2291      {
    2292        String methodCall = "updateTimestamp(" + columnName + ", " + x + ")";
    2293        try
    2294        {
    2295          realResultSet.updateTimestamp(columnName, x);
    2296        }
    2297        catch (SQLException s)
    2298        {
    2299          reportException(methodCall, s);
    2300          throw s;
    2301        }
    2302        reportReturn(methodCall);
    2303      }
    2304
    2305      public boolean first() throws SQLException
    2306      {
    2307        String methodCall = "first()";
    2308        try
    2309        {
    2310          return reportReturn(methodCall, realResultSet.first());
    2311        }
    2312        catch (SQLException s)
    2313        {
    2314          reportException(methodCall, s);
    2315          throw s;
    2316        }
    2317      }
    2318
    2319      public String getCursorName() throws SQLException
    2320      {
    2321        String methodCall = "getCursorName()";
    2322        try
    2323        {
    2324          return (String) reportReturn(methodCall, realResultSet.getCursorName());
    2325        }
    2326        catch (SQLException s)
    2327        {
    2328          reportException(methodCall, s);
    2329          throw s;
    2330        }
    2331      }
    2332
    2333      public int findColumn(String columnName) throws SQLException
    2334      {
    2335        String methodCall = "findColumn(" + columnName + ")";
    2336        try
    2337        {
    2338          return reportReturn(methodCall, realResultSet.findColumn(columnName));
    2339        }
    2340        catch (SQLException s)
    2341        {
    2342          reportException(methodCall, s);
    2343          throw s;
    2344        }
    2345      }
    2346
    2347      public boolean wasNull() throws SQLException
    2348      {
    2349        String methodCall = "wasNull()";
    2350        try
    2351        {
    2352          return reportReturn(methodCall, realResultSet.wasNull());
    2353        }
    2354        catch (SQLException s)
    2355        {
    2356          reportException(methodCall, s);
    2357          throw s;
    2358        }
    2359      }
    2360
    2361      public void updateBinaryStream(int columnIndex, InputStream x, int length) throws SQLException
    2362      {
    2363        String methodCall = "updateBinaryStream(" + columnIndex + ", " + x + ", " + length + ")";
    2364        try
    2365        {
    2366          realResultSet.updateBinaryStream(columnIndex, x, length);
    2367        }
    2368        catch (SQLException s)
    2369        {
    2370          reportException(methodCall, s);
    2371          throw s;
    2372        }
    2373        reportReturn(methodCall);
    2374      }
    2375
    2376      public void updateBinaryStream(String columnName, InputStream x, int length) throws SQLException
    2377      {
    2378        String methodCall = "updateBinaryStream(" + columnName + ", " + x + ", " + length + ")";
    2379        try
    2380        {
    2381          realResultSet.updateBinaryStream(columnName, x, length);
    2382        }
    2383        catch (SQLException s)
    2384        {
    2385          reportException(methodCall, s);
    2386          throw s;
    2387        }
    2388        reportReturn(methodCall);
    2389      }
    2390
    2391      public String getString(int columnIndex) throws SQLException
    2392      {
    2393        String methodCall = "getString(" + columnIndex + ")";
    2394        try
    2395        {
    2396          return (String) reportReturn(methodCall, realResultSet.getString(columnIndex));
    2397        }
    2398        catch (SQLException s)
    2399        {
    2400          reportException(methodCall, s);
    2401          throw s;
    2402        }
    2403      }
    2404
    2405      public String getString(String columnName) throws SQLException
    2406      {
    2407        String methodCall = "getString(" + columnName + ")";
    2408        try
    2409        {
    2410          return (String) reportReturn(methodCall, realResultSet.getString(columnName));
    2411        }
    2412        catch (SQLException s)
    2413        {
    2414          reportException(methodCall, s);
    2415          throw s;
    2416        }
    2417      }
    2418
    2419      public Reader getCharacterStream(int columnIndex) throws SQLException
    2420      {
    2421        String methodCall = "getCharacterStream(" + columnIndex + ")";
    2422        try
    2423        {
    2424          return (Reader) reportReturn(methodCall, realResultSet.getCharacterStream(columnIndex));
    2425        }
    2426        catch (SQLException s)
    2427        {
    2428          reportException(methodCall, s);
    2429          throw s;
    2430        }
    2431      }
    2432
    2433      public Reader getCharacterStream(String columnName) throws SQLException
    2434      {
    2435        String methodCall = "getCharacterStream(" + columnName + ")";
    2436        try
    2437        {
    2438          return (Reader) reportReturn(methodCall, realResultSet.getCharacterStream(columnName));
    2439        }
    2440        catch (SQLException s)
    2441        {
    2442          reportException(methodCall, s);
    2443          throw s;
    2444        }
    2445      }
    2446
    2447      public void setFetchDirection(int direction) throws SQLException
    2448      {
    2449        String methodCall = "setFetchDirection(" + direction + ")";
    2450        try
    2451        {
    2452          realResultSet.setFetchDirection(direction);
    2453        }
    2454        catch (SQLException s)
    2455        {
    2456          reportException(methodCall, s);
    2457          throw s;
    2458        }
    2459        reportReturn(methodCall);
    2460      }
    2461
    2462      public void updateCharacterStream(int columnIndex, Reader x, int length) throws SQLException
    2463      {
    2464        String methodCall = "updateCharacterStream(" + columnIndex + ", " + x + ", " + length + ")";
    2465        try
    2466        {
    2467          realResultSet.updateCharacterStream(columnIndex, x, length);
    2468        }
    2469        catch (SQLException s)
    2470        {
    2471          reportException(methodCall, s);
    2472          throw s;
    2473        }
    2474        reportReturn(methodCall);
    2475      }
    2476
    2477      public void updateCharacterStream(String columnName, Reader reader, int length) throws SQLException
    2478      {
    2479        String methodCall = "updateCharacterStream(" + columnName + ", " + reader + ", " + length + ")";
    2480        try
    2481        {
    2482          realResultSet.updateCharacterStream(columnName, reader, length);
    2483        }
    2484        catch (SQLException s)
    2485        {
    2486          reportException(methodCall, s);
    2487          throw s;
    2488        }
    2489        reportReturn(methodCall);
    2490      }
    2491
    2492      public byte getByte(int columnIndex) throws SQLException
    2493      {
    2494        String methodCall = "getByte(" + columnIndex + ")";
    2495        try
    2496        {
    2497          return reportReturn(methodCall, realResultSet.getByte(columnIndex));
    2498        }
    2499        catch (SQLException s)
    2500        {
    2501          reportException(methodCall, s);
    2502          throw s;
    2503        }
    2504      }
    2505
    2506      public byte getByte(String columnName) throws SQLException
    2507      {
    2508        String methodCall = "getByte(" + columnName + ")";
    2509        try
    2510        {
    2511          return reportReturn(methodCall, realResultSet.getByte(columnName));
    2512        }
    2513        catch (SQLException s)
    2514        {
    2515          reportException(methodCall, s);
    2516          throw s;
    2517        }
    2518      }
    2519
    2520      public void updateTime(int columnIndex, Time x) throws SQLException
    2521      {
    2522        String methodCall = "updateTime(" + columnIndex + ", " + x + ")";
    2523        try
    2524        {
    2525          realResultSet.updateTime(columnIndex, x);
    2526        }
    2527        catch (SQLException s)
    2528        {
    2529          reportException(methodCall, s);
    2530          throw s;
    2531        }
    2532        reportReturn(methodCall);
    2533      }
    2534
    2535      public void updateTime(String columnName, Time x) throws SQLException
    2536      {
    2537        String methodCall = "updateTime(" + columnName + ", " + x + ")";
    2538        try
    2539        {
    2540          realResultSet.updateTime(columnName, x);
    2541        }
    2542        catch (SQLException s)
    2543        {
    2544          reportException(methodCall, s);
    2545          throw s;
    2546        }
    2547        reportReturn(methodCall);
    2548      }
    2549
    2550      public byte[] getBytes(int columnIndex) throws SQLException
    2551      {
    2552        String methodCall = "getBytes(" + columnIndex + ")";
    2553        try
    2554        {
    2555          return (byte[]) reportReturn(methodCall, realResultSet.getBytes(columnIndex));
    2556        }
    2557        catch (SQLException s)
    2558        {
    2559          reportException(methodCall, s);
    2560          throw s;
    2561        }
    2562      }
    2563
    2564      public byte[] getBytes(String columnName) throws SQLException
    2565      {
    2566        String methodCall = "getBytes(" + columnName + ")";
    2567        try
    2568        {
    2569          return (byte[]) reportReturn(methodCall, realResultSet.getBytes(columnName));
    2570        }
    2571        catch (SQLException s)
    2572        {
    2573          reportException(methodCall, s);
    2574          throw s;
    2575        }
    2576      }
    2577
    2578      public boolean isAfterLast() throws SQLException
    2579      {
    2580        String methodCall = "isAfterLast()";
    2581        try
    2582        {
    2583          return reportReturn(methodCall, realResultSet.isAfterLast());
    2584        }
    2585        catch (SQLException s)
    2586        {
    2587          reportException(methodCall, s);
    2588          throw s;
    2589        }
    2590      }
    2591
    2592      public void updateObject(int columnIndex, Object x, int scale) throws SQLException
    2593      {
    2594        String methodCall = "updateObject(" + columnIndex + ", " + x + ", " + scale + ")";
    2595        try
    2596        {
    2597          realResultSet.updateObject(columnIndex, x, scale);
    2598        }
    2599        catch (SQLException s)
    2600        {
    2601          reportException(methodCall, s);
    2602          throw s;
    2603        }
    2604        reportReturn(methodCall);
    2605      }
    2606
    2607      public void updateObject(int columnIndex, Object x) throws SQLException
    2608      {
    2609        String methodCall = "updateObject(" + columnIndex + ", " + x + ")";
    2610        try
    2611        {
    2612          realResultSet.updateObject(columnIndex, x);
    2613        }
    2614        catch (SQLException s)
    2615        {
    2616          reportException(methodCall, s);
    2617          throw s;
    2618        }
    2619        reportReturn(methodCall);
    2620      }
    2621
    2622      public void updateObject(String columnName, Object x, int scale) throws SQLException
    2623      {
    2624        String methodCall = "updateObject(" + columnName + ", " + x + ", " + scale + ")";
    2625        try
    2626        {
    2627          realResultSet.updateObject(columnName, x, scale);
    2628        }
    2629        catch (SQLException s)
    2630        {
    2631          reportException(methodCall, s);
    2632          throw s;
    2633        }
    2634        reportReturn(methodCall);
    2635      }
    2636
    2637      public void updateObject(String columnName, Object x) throws SQLException
    2638      {
    2639        String methodCall = "updateObject(" + columnName + ", " + x + ")";
    2640        try
    2641        {
    2642          realResultSet.updateObject(columnName, x);
    2643        }
    2644        catch (SQLException s)
    2645        {
    2646          reportException(methodCall, s);
    2647          throw s;
    2648        }
    2649        reportReturn(methodCall);
    2650      }
    2651
    2652      public int getFetchDirection() throws SQLException
    2653      {
    2654        String methodCall = "getFetchDirection()";
    2655        try
    2656        {
    2657          return reportReturn(methodCall, realResultSet.getFetchDirection());
    2658        }
    2659        catch (SQLException s)
    2660        {
    2661          reportException(methodCall, s);
    2662          throw s;
    2663        }
    2664      }
    2665
    2666      public long getLong(int columnIndex) throws SQLException
    2667      {
    2668        String methodCall = "getLong(" + columnIndex + ")";
    2669        try
    2670        {
    2671          return reportReturn(methodCall, realResultSet.getLong(columnIndex));
    2672        }
    2673        catch (SQLException s)
    2674        {
    2675          reportException(methodCall, s);
    2676          throw s;
    2677        }
    2678      }
    2679
    2680      public long getLong(String columnName) throws SQLException
    2681      {
    2682        String methodCall = "getLong(" + columnName + ")";
    2683        try
    2684        {
    2685          return reportReturn(methodCall, realResultSet.getLong(columnName));
    2686        }
    2687        catch (SQLException s)
    2688        {
    2689          reportException(methodCall, s);
    2690          throw s;
    2691        }
    2692      }
    2693
    2694      public boolean isFirst() throws SQLException
    2695      {
    2696        String methodCall = "isFirst()";
    2697        try
    2698        {
    2699          return reportReturn(methodCall, realResultSet.isFirst());
    2700        }
    2701        catch (SQLException s)
    2702        {
    2703          reportException(methodCall, s);
    2704          throw s;
    2705        }
    2706      }
    2707
    2708      public void insertRow() throws SQLException
    2709      {
    2710        String methodCall = "insertRow()";
    2711        try
    2712        {
    2713          realResultSet.insertRow();
    2714        }
    2715        catch (SQLException s)
    2716        {
    2717          reportException(methodCall, s);
    2718          throw s;
    2719        }
    2720      }
    2721
    2722      public float getFloat(int columnIndex) throws SQLException
    2723      {
    2724        String methodCall = "getFloat(" + columnIndex + ")";
    2725        try
    2726        {
    2727          return reportReturn(methodCall, realResultSet.getFloat(columnIndex));
    2728        }
    2729        catch (SQLException s)
    2730        {
    2731          reportException(methodCall, s);
    2732          throw s;
    2733        }
    2734      }
    2735
    2736      public float getFloat(String columnName) throws SQLException
    2737      {
    2738        String methodCall = "getFloat(" + columnName + ")";
    2739        try
    2740        {
    2741          return reportReturn(methodCall, realResultSet.getFloat(columnName));
    2742        }
    2743        catch (SQLException s)
    2744        {
    2745          reportException(methodCall, s);
    2746          throw s;
    2747        }
    2748      }
    2749
    2750      public boolean isLast() throws SQLException
    2751      {
    2752        String methodCall = "isLast()";
    2753        try
    2754        {
    2755          return reportReturn(methodCall, realResultSet.isLast());
    2756        }
    2757        catch (SQLException s)
    2758        {
    2759          reportException(methodCall, s);
    2760          throw s;
    2761        }
    2762      }
    2763
    2764      public void setFetchSize(int rows) throws SQLException
    2765      {
    2766        String methodCall = "setFetchSize(" + rows + ")";
    2767        try
    2768        {
    2769          realResultSet.setFetchSize(rows);
    2770        }
    2771        catch (SQLException s)
    2772        {
    2773          reportException(methodCall, s);
    2774          throw s;
    2775        }
    2776        reportReturn(methodCall);
    2777      }
    2778
    2779      public void updateRow() throws SQLException
    2780      {
    2781        String methodCall = "updateRow()";
    2782        try
    2783        {
    2784          realResultSet.updateRow();
    2785        }
    2786        catch (SQLException s)
    2787        {
    2788          reportException(methodCall, s);
    2789          throw s;
    2790        }
    2791        reportReturn(methodCall);
    2792      }
    2793
    2794      public void beforeFirst() throws SQLException
    2795      {
    2796        String methodCall = "beforeFirst()";
    2797        try
    2798        {
    2799          realResultSet.beforeFirst();
    2800        }
    2801        catch (SQLException s)
    2802        {
    2803          reportException(methodCall, s);
    2804          throw s;
    2805        }
    2806        reportReturn(methodCall);
    2807      }
    2808
    2809      /**
    2810       * @deprecated
    2811       */
    2812      public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException
    2813      {
    2814        String methodCall = "getBigDecimal(" + columnIndex + ", " + scale + ")";
    2815        try
    2816        {
    2817          return (BigDecimal) reportReturn(methodCall, realResultSet.getBigDecimal(columnIndex, scale));
    2818        }
    2819        catch (SQLException s)
    2820        {
    2821          reportException(methodCall, s);
    2822          throw s;
    2823        }
    2824      }
    2825
    2826      /**
    2827       * @deprecated
    2828       */
    2829      public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException
    2830      {
    2831        String methodCall = "getBigDecimal(" + columnName + ", " + scale + ")";
    2832        try
    2833        {
    2834          return (BigDecimal) reportReturn(methodCall, realResultSet.getBigDecimal(columnName, scale));
    2835        }
    2836        catch (SQLException s)
    2837        {
    2838          reportException(methodCall, s);
    2839          throw s;
    2840        }
    2841      }
    2842
    2843      public BigDecimal getBigDecimal(int columnIndex) throws SQLException
    2844      {
    2845        String methodCall = "getBigDecimal(" + columnIndex + ")";
    2846        try
    2847        {
    2848          return (BigDecimal) reportReturn(methodCall, realResultSet.getBigDecimal(columnIndex));
    2849        }
    2850        catch (SQLException s)
    2851        {
    2852          reportException(methodCall, s);
    2853          throw s;
    2854        }
    2855      }
    2856
    2857      public BigDecimal getBigDecimal(String columnName) throws SQLException
    2858      {
    2859        String methodCall = "getBigDecimal(" + columnName + ")";
    2860        try
    2861        {
    2862          return (BigDecimal) reportReturn(methodCall, realResultSet.getBigDecimal(columnName));
    2863        }
    2864        catch (SQLException s)
    2865        {
    2866          reportException(methodCall, s);
    2867          throw s;
    2868        }
    2869      }
    2870
    2871      public void afterLast() throws SQLException
    2872      {
    2873        String methodCall = "afterLast()";
    2874        try
    2875        {
    2876          realResultSet.afterLast();
    2877        }
    2878        catch (SQLException s)
    2879        {
    2880          reportException(methodCall, s);
    2881          throw s;
    2882        }
    2883        reportReturn(methodCall);
    2884      }
    2885
    2886      public void refreshRow() throws SQLException
    2887      {
    2888        String methodCall = "refreshRow()";
    2889        try
    2890        {
    2891          realResultSet.refreshRow();
    2892        }
    2893        catch (SQLException s)
    2894        {
    2895          reportException(methodCall, s);
    2896          throw s;
    2897        }
    2898      }
    2899
    2900      public <T> T unwrap(Class<T> iface) throws SQLException {
    2901        String methodCall = "unwrap(" + (iface==null?"null":iface.getName()) + ")";
    2902        try
    2903        {
    2904          //todo: double check this logic
    2905          return (T)reportReturn(methodCall, (iface != null && (iface == ResultSet.class || iface == Spy.class))?(T)this:realResultSet.unwrap(iface));
    2906        }
    2907        catch (SQLException s)
    2908        {
    2909          reportException(methodCall,s);
    2910          throw s;
    2911        }
    2912      }
    2913
    2914      public boolean isWrapperFor(Class<?> iface) throws SQLException
    2915      {
    2916        String methodCall = "isWrapperFor(" + (iface==null?"null":iface.getName()) + ")";
    2917        try
    2918        {
    2919          return reportReturn(methodCall, (iface != null && (iface == ResultSet.class || iface == Spy.class)) ||
    2920              realResultSet.isWrapperFor(iface));
    2921        }
    2922        catch (SQLException s)
    2923        {
    2924          reportException(methodCall,s);
    2925          throw s;
    2926        }
    2927      }
    2928    }