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