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