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 }