Java > Open Source Codes > com > mysql > jdbc > jdbc2 > optional > CallableStatementWrapper


1 /*
2  Copyright (C) 2002-2004 MySQL AB
3
4  This program is free software; you can redistribute it and/or modify
5  it under the terms of version 2 of the GNU General Public License as
6  published by the Free Software Foundation.
7
8  There are special exceptions to the terms and conditions of the GPL
9  as it is applied to this software. View the full text of the
10  exception in file EXCEPTIONS-CONNECTOR-J in the directory of this
11  software distribution.
12
13  This program is distributed in the hope that it will be useful,
14  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  GNU General Public License for more details.
17
18  You should have received a copy of the GNU General Public License
19  along with this program; if not, write to the Free Software
20  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21
22
23  */
24
25 package com.mysql.jdbc.jdbc2.optional;
26
27 import java.io.InputStream ;
28 import java.io.Reader ;
29 import java.math.BigDecimal ;
30 import java.net.URL ;
31 import java.sql.Array ;
32 import java.sql.Blob ;
33 import java.sql.CallableStatement ;
34 import java.sql.Clob ;
35 import java.sql.Date ;
36 import java.sql.PreparedStatement ;
37 import java.sql.Ref ;
38 import java.sql.SQLException ;
39 import java.sql.Time ;
40 import java.sql.Timestamp ;
41 import java.util.Calendar ;
42 import java.util.Map ;
43
44 import com.mysql.jdbc.SQLError;
45
46 /**
47  * Wraps callable statements created by pooled connections.
48  *
49  * @version $Id: CallableStatementWrapper.java,v 1.1.2.1 2005/05/13 18:58:38
50  * mmatthews Exp $
51  */
52 public class CallableStatementWrapper extends PreparedStatementWrapper
53         implements CallableStatement {
54
55     /**
56      * @param c
57      * @param conn
58      * @param toWrap
59      */
60     public CallableStatementWrapper(ConnectionWrapper c,
61             MysqlPooledConnection conn, CallableStatement toWrap) {
62         super(c, conn, toWrap);
63     }
64
65     /*
66      * (non-Javadoc)
67      *
68      * @see java.sql.CallableStatement#registerOutParameter(int, int)
69      */
70     public void registerOutParameter(int parameterIndex, int sqlType)
71             throws SQLException {
72         try {
73             if (this.wrappedStmt != null) {
74                 ((CallableStatement ) this.wrappedStmt).registerOutParameter(
75                         parameterIndex, sqlType);
76             } else {
77                 throw new SQLException (
78                         "No operations allowed after statement closed",
79                         SQLError.SQL_STATE_GENERAL_ERROR);
80             }
81         } catch (SQLException sqlEx) {
82             checkAndFireConnectionError(sqlEx);
83         }
84     }
85
86     /*
87      * (non-Javadoc)
88      *
89      * @see java.sql.CallableStatement#registerOutParameter(int, int, int)
90      */
91     public void registerOutParameter(int parameterIndex, int sqlType, int scale)
92             throws SQLException {
93         try {
94             if (this.wrappedStmt != null) {
95                 ((CallableStatement ) this.wrappedStmt).registerOutParameter(
96                         parameterIndex, sqlType, scale);
97             } else {
98                 throw new SQLException (
99                         "No operations allowed after statement closed",
100                         SQLError.SQL_STATE_GENERAL_ERROR);
101             }
102         } catch (SQLException sqlEx) {
103             checkAndFireConnectionError(sqlEx);
104         }
105     }
106
107     /*
108      * (non-Javadoc)
109      *
110      * @see java.sql.CallableStatement#wasNull()
111      */
112     public boolean wasNull() throws SQLException {
113         try {
114             if (this.wrappedStmt != null) {
115                 return ((CallableStatement ) this.wrappedStmt).wasNull();
116             } else {
117                 throw new SQLException (
118                         "No operations allowed after statement closed",
119                         SQLError.SQL_STATE_GENERAL_ERROR);
120             }
121         } catch (SQLException sqlEx) {
122             checkAndFireConnectionError(sqlEx);
123         }
124
125         return false;
126     }
127
128     /*
129      * (non-Javadoc)
130      *
131      * @see java.sql.CallableStatement#getString(int)
132      */
133     public String getString(int parameterIndex) throws SQLException {
134         try {
135             if (this.wrappedStmt != null) {
136                 return ((CallableStatement ) this.wrappedStmt)
137                         .getString(parameterIndex);
138             } else {
139                 throw new SQLException (
140                         "No operations allowed after statement closed",
141                         SQLError.SQL_STATE_GENERAL_ERROR);
142             }
143         } catch (SQLException sqlEx) {
144             checkAndFireConnectionError(sqlEx);
145         }
146         return null;
147     }
148
149     /*
150      * (non-Javadoc)
151      *
152      * @see java.sql.CallableStatement#getBoolean(int)
153      */
154     public boolean getBoolean(int parameterIndex) throws SQLException {
155         try {
156             if (this.wrappedStmt != null) {
157                 return ((CallableStatement ) this.wrappedStmt)
158                         .getBoolean(parameterIndex);
159             } else {
160                 throw new SQLException (
161                         "No operations allowed after statement closed",
162                         SQLError.SQL_STATE_GENERAL_ERROR);
163             }
164         } catch (SQLException sqlEx) {
165             checkAndFireConnectionError(sqlEx);
166         }
167
168         return false;
169     }
170
171     /*
172      * (non-Javadoc)
173      *
174      * @see java.sql.CallableStatement#getByte(int)
175      */
176     public byte getByte(int parameterIndex) throws SQLException {
177         try {
178             if (this.wrappedStmt != null) {
179                 return ((CallableStatement ) this.wrappedStmt)
180                         .getByte(parameterIndex);
181             } else {
182                 throw new SQLException (
183                         "No operations allowed after statement closed",
184                         SQLError.SQL_STATE_GENERAL_ERROR);
185             }
186         } catch (SQLException sqlEx) {
187             checkAndFireConnectionError(sqlEx);
188         }
189
190         return 0;
191     }
192
193     /*
194      * (non-Javadoc)
195      *
196      * @see java.sql.CallableStatement#getShort(int)
197      */
198     public short getShort(int parameterIndex) throws SQLException {
199         try {
200             if (this.wrappedStmt != null) {
201                 return ((CallableStatement ) this.wrappedStmt)
202                         .getShort(parameterIndex);
203             } else {
204                 throw new SQLException (
205                         "No operations allowed after statement closed",
206                         SQLError.SQL_STATE_GENERAL_ERROR);
207             }
208         } catch (SQLException sqlEx) {
209             checkAndFireConnectionError(sqlEx);
210         }
211
212         return 0;
213     }
214
215     /*
216      * (non-Javadoc)
217      *
218      * @see java.sql.CallableStatement#getInt(int)
219      */
220     public int getInt(int parameterIndex) throws SQLException {
221         try {
222             if (this.wrappedStmt != null) {
223                 return ((CallableStatement ) this.wrappedStmt)
224                         .getInt(parameterIndex);
225             } else {
226                 throw new SQLException (
227                         "No operations allowed after statement closed",
228                         SQLError.SQL_STATE_GENERAL_ERROR);
229             }
230         } catch (SQLException sqlEx) {
231             checkAndFireConnectionError(sqlEx);
232         }
233
234         return 0;
235     }
236
237     /*
238      * (non-Javadoc)
239      *
240      * @see java.sql.CallableStatement#getLong(int)
241      */
242     public long getLong(int parameterIndex) throws SQLException {
243         try {
244             if (this.wrappedStmt != null) {
245                 return ((CallableStatement ) this.wrappedStmt)
246                         .getLong(parameterIndex);
247             } else {
248                 throw new SQLException (
249                         "No operations allowed after statement closed",
250                         SQLError.SQL_STATE_GENERAL_ERROR);
251             }
252         } catch (SQLException sqlEx) {
253             checkAndFireConnectionError(sqlEx);
254         }
255
256         return 0;
257     }
258
259     /*
260      * (non-Javadoc)
261      *
262      * @see java.sql.CallableStatement#getFloat(int)
263      */
264     public float getFloat(int parameterIndex) throws SQLException {
265         try {
266             if (this.wrappedStmt != null) {
267                 return ((CallableStatement ) this.wrappedStmt)
268                         .getFloat(parameterIndex);
269             } else {
270                 throw new SQLException (
271                         "No operations allowed after statement closed",
272                         SQLError.SQL_STATE_GENERAL_ERROR);
273             }
274         } catch (SQLException sqlEx) {
275             checkAndFireConnectionError(sqlEx);
276         }
277
278         return 0;
279     }
280
281     /*
282      * (non-Javadoc)
283      *
284      * @see java.sql.CallableStatement#getDouble(int)
285      */
286     public double getDouble(int parameterIndex) throws SQLException {
287         try {
288             if (this.wrappedStmt != null) {
289                 return ((CallableStatement ) this.wrappedStmt)
290                         .getDouble(parameterIndex);
291             } else {
292                 throw new SQLException (
293                         "No operations allowed after statement closed",
294                         SQLError.SQL_STATE_GENERAL_ERROR);
295             }
296         } catch (SQLException sqlEx) {
297             checkAndFireConnectionError(sqlEx);
298         }
299
300         return 0;
301     }
302
303     /*
304      * (non-Javadoc)
305      *
306      * @see java.sql.CallableStatement#getBigDecimal(int, int)
307      */
308     public BigDecimal getBigDecimal(int parameterIndex, int scale)
309             throws SQLException {
310         try {
311             if (this.wrappedStmt != null) {
312                 return ((CallableStatement ) this.wrappedStmt).getBigDecimal(
313                         parameterIndex, scale);
314             } else {
315                 throw new SQLException (
316                         "No operations allowed after statement closed",
317                         SQLError.SQL_STATE_GENERAL_ERROR);
318             }
319         } catch (SQLException sqlEx) {
320             checkAndFireConnectionError(sqlEx);
321         }
322
323         return null;
324     }
325
326     /*
327      * (non-Javadoc)
328      *
329      * @see java.sql.CallableStatement#getBytes(int)
330      */
331     public byte[] getBytes(int parameterIndex) throws SQLException {
332         try {
333             if (this.wrappedStmt != null) {
334                 return ((CallableStatement ) this.wrappedStmt)
335                         .getBytes(parameterIndex);
336             } else {
337                 throw new SQLException (
338                         "No operations allowed after statement closed",
339                         SQLError.SQL_STATE_GENERAL_ERROR);
340             }
341         } catch (SQLException sqlEx) {
342             checkAndFireConnectionError(sqlEx);
343         }
344
345         return null;
346     }
347
348     /*
349      * (non-Javadoc)
350      *
351      * @see java.sql.CallableStatement#getDate(int)
352      */
353     public Date getDate(int parameterIndex) throws SQLException {
354         try {
355             if (this.wrappedStmt != null) {
356                 return ((CallableStatement ) this.wrappedStmt)
357                         .getDate(parameterIndex);
358             } else {
359                 throw new SQLException (
360                         "No operations allowed after statement closed",
361                         SQLError.SQL_STATE_GENERAL_ERROR);
362             }
363         } catch (SQLException sqlEx) {
364             checkAndFireConnectionError(sqlEx);
365         }
366
367         return null;
368     }
369
370     /*
371      * (non-Javadoc)
372      *
373      * @see java.sql.CallableStatement#getTime(int)
374      */
375     public Time getTime(int parameterIndex) throws SQLException {
376         try {
377             if (this.wrappedStmt != null) {
378                 return ((CallableStatement ) this.wrappedStmt)
379                         .getTime(parameterIndex);
380             } else {
381                 throw new SQLException (
382                         "No operations allowed after statement closed",
383                         SQLError.SQL_STATE_GENERAL_ERROR);
384             }
385         } catch (SQLException sqlEx) {
386             checkAndFireConnectionError(sqlEx);
387         }
388
389         return null;
390     }
391
392     /*
393      * (non-Javadoc)
394      *
395      * @see java.sql.CallableStatement#getTimestamp(int)
396      */
397     public Timestamp getTimestamp(int parameterIndex) throws SQLException {
398         try {
399             if (this.wrappedStmt != null) {
400                 return ((CallableStatement ) this.wrappedStmt)
401                         .getTimestamp(parameterIndex);
402             } else {
403                 throw new SQLException (
404                         "No operations allowed after statement closed",
405                         SQLError.SQL_STATE_GENERAL_ERROR);
406             }
407         } catch (SQLException sqlEx) {
408             checkAndFireConnectionError(sqlEx);
409         }
410
411         return null;
412     }
413
414     /*
415      * (non-Javadoc)
416      *
417      * @see java.sql.CallableStatement#getObject(int)
418      */
419     public Object getObject(int parameterIndex) throws SQLException {
420         try {
421             if (this.wrappedStmt != null) {
422                 return ((CallableStatement ) this.wrappedStmt)
423                         .getObject(parameterIndex);
424             } else {
425                 throw new SQLException (
426                         "No operations allowed after statement closed",
427                         SQLError.SQL_STATE_GENERAL_ERROR);
428             }
429         } catch (SQLException sqlEx) {
430             checkAndFireConnectionError(sqlEx);
431         }
432
433         return null;
434     }
435
436     /*
437      * (non-Javadoc)
438      *
439      * @see java.sql.CallableStatement#getBigDecimal(int)
440      */
441     public BigDecimal getBigDecimal(int parameterIndex) throws SQLException {
442         try {
443             if (this.wrappedStmt != null) {
444                 return ((CallableStatement ) this.wrappedStmt)
445                         .getBigDecimal(parameterIndex);
446             } else {
447                 throw new SQLException (
448                         "No operations allowed after statement closed",
449                         SQLError.SQL_STATE_GENERAL_ERROR);
450             }
451         } catch (SQLException sqlEx) {
452             checkAndFireConnectionError(sqlEx);
453         }
454
455         return null;
456     }
457
458     /*
459      * (non-Javadoc)
460      *
461      * @see java.sql.CallableStatement#getObject(int, java.util.Map)
462      */
463     public Object getObject(int parameterIndex, Map typeMap)
464             throws SQLException {
465         try {
466             if (this.wrappedStmt != null) {
467                 return ((CallableStatement ) this.wrappedStmt).getObject(
468                         parameterIndex, typeMap);
469             } else {
470                 throw new SQLException (
471                         "No operations allowed after statement closed",
472                         SQLError.SQL_STATE_GENERAL_ERROR);
473             }
474         } catch (SQLException sqlEx) {
475             checkAndFireConnectionError(sqlEx);
476         }
477         return null;
478     }
479
480     /*
481      * (non-Javadoc)
482      *
483      * @see java.sql.CallableStatement#getRef(int)
484      */
485     public Ref getRef(int parameterIndex) throws SQLException {
486         try {
487             if (this.wrappedStmt != null) {
488                 return ((CallableStatement ) this.wrappedStmt)
489                         .getRef(parameterIndex);
490             } else {
491                 throw new SQLException (
492                         "No operations allowed after statement closed",
493                         SQLError.SQL_STATE_GENERAL_ERROR);
494             }
495         } catch (SQLException sqlEx) {
496             checkAndFireConnectionError(sqlEx);
497         }
498
499         return null;
500     }
501
502     /*
503      * (non-Javadoc)
504      *
505      * @see java.sql.CallableStatement#getBlob(int)
506      */
507     public Blob getBlob(int parameterIndex) throws SQLException {
508         try {
509             if (this.wrappedStmt != null) {
510                 return ((CallableStatement ) this.wrappedStmt)
511                         .getBlob(parameterIndex);
512             } else {
513                 throw new SQLException (
514                         "No operations allowed after statement closed",
515                         SQLError.SQL_STATE_GENERAL_ERROR);
516             }
517         } catch (SQLException sqlEx) {
518             checkAndFireConnectionError(sqlEx);
519         }
520
521         return null;
522     }
523
524     /*
525      * (non-Javadoc)
526      *
527      * @see java.sql.CallableStatement#getClob(int)
528      */
529     public Clob getClob(int parameterIndex) throws SQLException {
530         try {
531             if (this.wrappedStmt != null) {
532                 return ((CallableStatement ) this.wrappedStmt)
533                         .getClob(parameterIndex);
534             } else {
535                 throw new SQLException (
536                         "No operations allowed after statement closed",
537                         SQLError.SQL_STATE_GENERAL_ERROR);
538             }
539         } catch (SQLException sqlEx) {
540             checkAndFireConnectionError(sqlEx);
541         }
542         return null;
543     }
544
545     /*
546      * (non-Javadoc)
547      *
548      * @see java.sql.CallableStatement#getArray(int)
549      */
550     public Array getArray(int parameterIndex) throws SQLException {
551         try {
552             if (this.wrappedStmt != null) {
553                 return ((CallableStatement ) this.wrappedStmt)
554                         .getArray(parameterIndex);
555             } else {
556                 throw new SQLException (
557                         "No operations allowed after statement closed",
558                         SQLError.SQL_STATE_GENERAL_ERROR);
559             }
560         } catch (SQLException sqlEx) {
561             checkAndFireConnectionError(sqlEx);
562         }
563         return null;
564     }
565
566     /*
567      * (non-Javadoc)
568      *
569      * @see java.sql.CallableStatement#getDate(int, java.util.Calendar)
570      */
571     public Date getDate(int parameterIndex, Calendar cal) throws SQLException {
572         try {
573             if (this.wrappedStmt != null) {
574                 return ((CallableStatement ) this.wrappedStmt).getDate(
575                         parameterIndex, cal);
576             } else {
577                 throw new SQLException (
578                         "No operations allowed after statement closed",
579                         SQLError.SQL_STATE_GENERAL_ERROR);
580             }
581         } catch (SQLException sqlEx) {
582             checkAndFireConnectionError(sqlEx);
583         }
584         return null;
585     }
586
587     /*
588      * (non-Javadoc)
589      *
590      * @see java.sql.CallableStatement#getTime(int, java.util.Calendar)
591      */
592     public Time getTime(int parameterIndex, Calendar cal) throws SQLException {
593         try {
594             if (this.wrappedStmt != null) {
595                 return ((CallableStatement ) this.wrappedStmt).getTime(
596                         parameterIndex, cal);
597             } else {
598                 throw new SQLException (
599                         "No operations allowed after statement closed",
600                         SQLError.SQL_STATE_GENERAL_ERROR);
601             }
602         } catch (SQLException sqlEx) {
603             checkAndFireConnectionError(sqlEx);
604         }
605         return null;
606     }
607
608     /*
609      * (non-Javadoc)
610      *
611      * @see java.sql.CallableStatement#getTimestamp(int, java.util.Calendar)
612      */
613     public Timestamp getTimestamp(int parameterIndex, Calendar cal)
614             throws SQLException {
615         try {
616             if (this.wrappedStmt != null) {
617                 return ((CallableStatement ) this.wrappedStmt).getTimestamp(
618                         parameterIndex, cal);
619             } else {
620                 throw new SQLException (
621                         "No operations allowed after statement closed",
622                         SQLError.SQL_STATE_GENERAL_ERROR);
623             }
624         } catch (SQLException sqlEx) {
625             checkAndFireConnectionError(sqlEx);
626         }
627         return null;
628     }
629
630     /*
631      * (non-Javadoc)
632      *
633      * @see java.sql.CallableStatement#registerOutParameter(int, int,
634      * java.lang.String)
635      */
636     public void registerOutParameter(int paramIndex, int sqlType,
637             String typeName) throws SQLException {
638         try {
639             if (this.wrappedStmt != null) {
640                 ((CallableStatement ) this.wrappedStmt).registerOutParameter(
641                         paramIndex, sqlType, typeName);
642             } else {
643                 throw new SQLException (
644                         "No operations allowed after statement closed",
645                         SQLError.SQL_STATE_GENERAL_ERROR);
646             }
647         } catch (SQLException sqlEx) {
648             checkAndFireConnectionError(sqlEx);
649         }
650     }
651
652     /*
653      * (non-Javadoc)
654      *
655      * @see java.sql.CallableStatement#registerOutParameter(java.lang.String,
656      * int)
657      */
658     public void registerOutParameter(String parameterName, int sqlType)
659             throws SQLException {
660         try {
661             if (this.wrappedStmt != null) {
662                 ((CallableStatement ) this.wrappedStmt).registerOutParameter(
663                         parameterName, sqlType);
664             } else {
665                 throw new SQLException (
666                         "No operations allowed after statement closed",
667                         SQLError.SQL_STATE_GENERAL_ERROR);
668             }
669         } catch (SQLException sqlEx) {
670             checkAndFireConnectionError(sqlEx);
671         }
672     }
673
674     /*
675      * (non-Javadoc)
676      *
677      * @see java.sql.CallableStatement#registerOutParameter(java.lang.String,
678      * int, int)
679      */
680     public void registerOutParameter(String parameterName, int sqlType,
681             int scale) throws SQLException {
682         try {
683             if (this.wrappedStmt != null) {
684                 ((CallableStatement ) this.wrappedStmt).registerOutParameter(
685                         parameterName, sqlType, scale);
686             } else {
687                 throw new SQLException (
688                         "No operations allowed after statement closed",
689                         SQLError.SQL_STATE_GENERAL_ERROR);
690             }
691         } catch (SQLException sqlEx) {
692             checkAndFireConnectionError(sqlEx);
693         }
694     }
695
696     /*
697      * (non-Javadoc)
698      *
699      * @see java.sql.CallableStatement#registerOutParameter(java.lang.String,
700      * int, java.lang.String)
701      */
702     public void registerOutParameter(String parameterName, int sqlType,
703             String typeName) throws SQLException {
704         try {
705             if (this.wrappedStmt != null) {
706                 ((CallableStatement ) this.wrappedStmt).registerOutParameter(
707                         parameterName, sqlType, typeName);
708             } else {
709                 throw new SQLException (
710                         "No operations allowed after statement closed",
711                         SQLError.SQL_STATE_GENERAL_ERROR);
712             }
713         } catch (SQLException sqlEx) {
714             checkAndFireConnectionError(sqlEx);
715         }
716     }
717
718     /*
719      * (non-Javadoc)
720      *
721      * @see java.sql.CallableStatement#getURL(int)
722      */
723     public URL getURL(int parameterIndex) throws SQLException {
724         try {
725             if (this.wrappedStmt != null) {
726                 return ((CallableStatement ) this.wrappedStmt)
727                         .getURL(parameterIndex);
728             } else {
729                 throw new SQLException (
730                         "No operations allowed after statement closed",
731                         SQLError.SQL_STATE_GENERAL_ERROR);
732             }
733         } catch (SQLException sqlEx) {
734             checkAndFireConnectionError(sqlEx);
735         }
736
737         return null;
738     }
739
740     /*
741      * (non-Javadoc)
742      *
743      * @see java.sql.CallableStatement#setURL(java.lang.String, java.net.URL)
744      */
745     public void setURL(String parameterName, URL val) throws SQLException {
746         try {
747             if (this.wrappedStmt != null) {
748                 ((CallableStatement ) this.wrappedStmt).setURL(parameterName,
749                         val);
750             } else {
751                 throw new SQLException (
752                         "No operations allowed after statement closed",
753                         SQLError.SQL_STATE_GENERAL_ERROR);
754             }
755         } catch (SQLException sqlEx) {
756             checkAndFireConnectionError(sqlEx);
757         }
758     }
759
760     /*
761      * (non-Javadoc)
762      *
763      * @see java.sql.CallableStatement#setNull(java.lang.String, int)
764      */
765     public void setNull(String parameterName, int sqlType) throws SQLException {
766         try {
767             if (this.wrappedStmt != null) {
768                 ((CallableStatement ) this.wrappedStmt).setNull(parameterName,
769                         sqlType);
770             } else {
771                 throw new SQLException (
772                         "No operations allowed after statement closed",
773                         SQLError.SQL_STATE_GENERAL_ERROR);
774             }
775         } catch (SQLException sqlEx) {
776             checkAndFireConnectionError(sqlEx);
777         }
778     }
779
780     /*
781      * (non-Javadoc)
782      *
783      * @see java.sql.CallableStatement#setBoolean(java.lang.String, boolean)
784      */
785     public void setBoolean(String parameterName, boolean x) throws SQLException {
786         try {
787             if (this.wrappedStmt != null) {
788                 ((CallableStatement ) this.wrappedStmt).setBoolean(
789                         parameterName, x);
790             } else {
791                 throw new SQLException (
792                         "No operations allowed after statement closed",
793                         SQLError.SQL_STATE_GENERAL_ERROR);
794             }
795         } catch (SQLException sqlEx) {
796             checkAndFireConnectionError(sqlEx);
797         }
798     }
799
800     /*
801      * (non-Javadoc)
802      *
803      * @see java.sql.CallableStatement#setByte(java.lang.String, byte)
804      */
805     public void setByte(String parameterName, byte x) throws SQLException {
806         try {
807             if (this.wrappedStmt != null) {
808                 ((CallableStatement ) this.wrappedStmt)
809                         .setByte(parameterName, x);
810             } else {
811                 throw new SQLException (
812                         "No operations allowed after statement closed",
813                         SQLError.SQL_STATE_GENERAL_ERROR);
814             }
815         } catch (SQLException sqlEx) {
816             checkAndFireConnectionError(sqlEx);
817         }
818     }
819
820     /*
821      * (non-Javadoc)
822      *
823      * @see java.sql.CallableStatement#setShort(java.lang.String, short)
824      */
825     public void setShort(String parameterName, short x) throws SQLException {
826         try {
827             if (this.wrappedStmt != null) {
828                 ((CallableStatement ) this.wrappedStmt).setShort(parameterName,
829                         x);
830             } else {
831                 throw new SQLException (
832                         "No operations allowed after statement closed",
833                         SQLError.SQL_STATE_GENERAL_ERROR);
834             }
835         } catch (SQLException sqlEx) {
836             checkAndFireConnectionError(sqlEx);
837         }
838     }
839
840     /*
841      * (non-Javadoc)
842      *
843      * @see java.sql.CallableStatement#setInt(java.lang.String, int)
844      */
845     public void setInt(String parameterName, int x) throws SQLException {
846         try {
847             if (this.wrappedStmt != null) {
848                 ((CallableStatement ) this.wrappedStmt).setInt(parameterName, x);
849             } else {
850                 throw new SQLException (
851                         "No operations allowed after statement closed",
852                         SQLError.SQL_STATE_GENERAL_ERROR);
853             }
854         } catch (SQLException sqlEx) {
855             checkAndFireConnectionError(sqlEx);
856         }
857     }
858
859     /*
860      * (non-Javadoc)
861      *
862      * @see java.sql.CallableStatement#setLong(java.lang.String, long)
863      */
864     public void setLong(String parameterName, long x) throws SQLException {
865         try {
866             if (this.wrappedStmt != null) {
867                 ((CallableStatement ) this.wrappedStmt)
868                         .setLong(parameterName, x);
869             } else {
870                 throw new SQLException (
871                         "No operations allowed after statement closed",
872                         SQLError.SQL_STATE_GENERAL_ERROR);
873             }
874         } catch (SQLException sqlEx) {
875             checkAndFireConnectionError(sqlEx);
876         }
877     }
878
879     /*
880      * (non-Javadoc)
881      *
882      * @see java.sql.CallableStatement#setFloat(java.lang.String, float)
883      */
884     public void setFloat(String parameterName, float x) throws SQLException {
885         try {
886             if (this.wrappedStmt != null) {
887                 ((CallableStatement ) this.wrappedStmt).setFloat(parameterName,
888                         x);
889             } else {
890                 throw new SQLException (
891                         "No operations allowed after statement closed",
892                         SQLError.SQL_STATE_GENERAL_ERROR);
893             }
894         } catch (SQLException sqlEx) {
895             checkAndFireConnectionError(sqlEx);
896         }
897     }
898
899     /*
900      * (non-Javadoc)
901      *
902      * @see java.sql.CallableStatement#setDouble(java.lang.String, double)
903      */
904     public void setDouble(String parameterName, double x) throws SQLException {
905         try {
906             if (this.wrappedStmt != null) {
907                 ((CallableStatement ) this.wrappedStmt).setDouble(parameterName,
908                         x);
909             } else {
910                 throw new SQLException (
911                         "No operations allowed after statement closed",
912                         SQLError.SQL_STATE_GENERAL_ERROR);
913             }
914         } catch (SQLException sqlEx) {
915             checkAndFireConnectionError(sqlEx);
916         }
917     }
918
919     /*
920      * (non-Javadoc)
921      *
922      * @see java.sql.CallableStatement#setBigDecimal(java.lang.String,
923      * java.math.BigDecimal)
924      */
925     public void setBigDecimal(String parameterName, BigDecimal x)
926             throws SQLException {
927         try {
928             if (this.wrappedStmt != null) {
929                 ((CallableStatement ) this.wrappedStmt).setBigDecimal(
930                         parameterName, x);
931             } else {
932                 throw new SQLException (
933                         "No operations allowed after statement closed",
934                         SQLError.SQL_STATE_GENERAL_ERROR);
935             }
936         } catch (SQLException sqlEx) {
937             checkAndFireConnectionError(sqlEx);
938         }
939     }
940
941     /*
942      * (non-Javadoc)
943      *
944      * @see java.sql.CallableStatement#setString(java.lang.String,
945      * java.lang.String)
946      */
947     public void setString(String parameterName, String x) throws SQLException {
948         try {
949             if (this.wrappedStmt != null) {
950                 ((CallableStatement ) this.wrappedStmt).setString(parameterName,
951                         x);
952             } else {
953                 throw new SQLException (
954                         "No operations allowed after statement closed",
955                         SQLError.SQL_STATE_GENERAL_ERROR);
956             }
957         } catch (SQLException sqlEx) {
958             checkAndFireConnectionError(sqlEx);
959         }
960     }
961
962     /*
963      * (non-Javadoc)
964      *
965      * @see java.sql.CallableStatement#setBytes(java.lang.String, byte[])
966      */
967     public void setBytes(String parameterName, byte[] x) throws SQLException {
968         try {
969             if (this.wrappedStmt != null) {
970                 ((CallableStatement ) this.wrappedStmt).setBytes(parameterName,
971                         x);
972             } else {
973                 throw new SQLException (
974                         "No operations allowed after statement closed",
975                         SQLError.SQL_STATE_GENERAL_ERROR);
976             }
977         } catch (SQLException sqlEx) {
978             checkAndFireConnectionError(sqlEx);
979         }
980     }
981
982     /*
983      * (non-Javadoc)
984      *
985      * @see java.sql.CallableStatement#setDate(java.lang.String, java.sql.Date)
986      */
987     public void setDate(String parameterName, Date x) throws SQLException {
988         try {
989             if (this.wrappedStmt != null) {
990                 ((CallableStatement ) this.wrappedStmt)
991                         .setDate(parameterName, x);
992             } else {
993                 throw new SQLException (
994                         "No operations allowed after statement closed",
995                         SQLError.SQL_STATE_GENERAL_ERROR);
996             }
997         } catch (SQLException sqlEx) {
998             checkAndFireConnectionError(sqlEx);
999         }
1000    }
1001
1002    /*
1003     * (non-Javadoc)
1004     *
1005     * @see java.sql.CallableStatement#setTime(java.lang.String, java.sql.Time)
1006     */
1007    public void setTime(String parameterName, Time x) throws SQLException {
1008        try {
1009            if (this.wrappedStmt != null) {
1010                ((CallableStatement ) this.wrappedStmt)
1011                        .setTime(parameterName, x);
1012            } else {
1013                throw new SQLException (
1014                        "No operations allowed after statement closed",
1015                        SQLError.SQL_STATE_GENERAL_ERROR);
1016            }
1017        } catch (SQLException sqlEx) {
1018            checkAndFireConnectionError(sqlEx);
1019        }
1020    }
1021
1022    /*
1023     * (non-Javadoc)
1024     *
1025     * @see java.sql.CallableStatement#setTimestamp(java.lang.String,
1026     * java.sql.Timestamp)
1027     */
1028    public void setTimestamp(String parameterName, Timestamp x)
1029            throws SQLException {
1030        try {
1031            if (this.wrappedStmt != null) {
1032                ((CallableStatement ) this.wrappedStmt).setTimestamp(
1033                        parameterName, x);
1034            } else {
1035                throw new SQLException (
1036                        "No operations allowed after statement closed",
1037                        SQLError.SQL_STATE_GENERAL_ERROR);
1038            }
1039        } catch (SQLException sqlEx) {
1040            checkAndFireConnectionError(sqlEx);
1041        }
1042    }
1043
1044    /*
1045     * (non-Javadoc)
1046     *
1047     * @see java.sql.CallableStatement#setAsciiStream(java.lang.String,
1048     * java.io.InputStream, int)
1049     */
1050    public void setAsciiStream(String parameterName, InputStream x, int length)
1051            throws SQLException {
1052        try {
1053            if (this.wrappedStmt != null) {
1054                ((CallableStatement ) this.wrappedStmt).setAsciiStream(
1055                        parameterName, x, length);
1056            } else {
1057                throw new SQLException (
1058                        "No operations allowed after statement closed",
1059                        SQLError.SQL_STATE_GENERAL_ERROR);
1060            }
1061        } catch (SQLException sqlEx) {
1062            checkAndFireConnectionError(sqlEx);
1063        }
1064
1065    }
1066
1067    /*
1068     * (non-Javadoc)
1069     *
1070     * @see java.sql.CallableStatement#setBinaryStream(java.lang.String,
1071     * java.io.InputStream, int)
1072     */
1073    public void setBinaryStream(String parameterName, InputStream x, int length)
1074            throws SQLException {
1075        try {
1076            if (this.wrappedStmt != null) {
1077                ((CallableStatement ) this.wrappedStmt).setBinaryStream(
1078                        parameterName, x, length);
1079            } else {
1080                throw new SQLException (
1081                        "No operations allowed after statement closed",
1082                        SQLError.SQL_STATE_GENERAL_ERROR);
1083            }
1084        } catch (SQLException sqlEx) {
1085            checkAndFireConnectionError(sqlEx);
1086        }
1087    }
1088
1089    /*
1090     * (non-Javadoc)
1091     *
1092     * @see java.sql.CallableStatement#setObject(java.lang.String,
1093     * java.lang.Object, int, int)
1094     */
1095    public void setObject(String parameterName, Object x, int targetSqlType,
1096            int scale) throws SQLException {
1097        try {
1098            if (this.wrappedStmt != null) {
1099                ((CallableStatement ) this.wrappedStmt).setObject(parameterName,
1100                        x, targetSqlType, scale);
1101            } else {
1102                throw new SQLException (
1103                        "No operations allowed after statement closed",
1104                        SQLError.SQL_STATE_GENERAL_ERROR);
1105            }
1106        } catch (SQLException sqlEx) {
1107            checkAndFireConnectionError(sqlEx);
1108        }
1109    }
1110
1111    /*
1112     * (non-Javadoc)
1113     *
1114     * @see java.sql.CallableStatement#setObject(java.lang.String,
1115     * java.lang.Object, int)
1116     */
1117    public void setObject(String parameterName, Object x, int targetSqlType)
1118            throws SQLException {
1119        try {
1120            if (this.wrappedStmt != null) {
1121                ((CallableStatement ) this.wrappedStmt).setObject(parameterName,
1122                        x, targetSqlType);
1123            } else {
1124                throw new SQLException (
1125                        "No operations allowed after statement closed",
1126                        SQLError.SQL_STATE_GENERAL_ERROR);
1127            }
1128        } catch (SQLException sqlEx) {
1129            checkAndFireConnectionError(sqlEx);
1130        }
1131    }
1132
1133    /*
1134     * (non-Javadoc)
1135     *
1136     * @see java.sql.CallableStatement#setObject(java.lang.String,
1137     * java.lang.Object)
1138     */
1139    public void setObject(String parameterName, Object x) throws SQLException {
1140        try {
1141            if (this.wrappedStmt != null) {
1142                ((CallableStatement ) this.wrappedStmt).setObject(parameterName,
1143                        x);
1144            } else {
1145                throw new SQLException (
1146                        "No operations allowed after statement closed",
1147                        SQLError.SQL_STATE_GENERAL_ERROR);
1148            }
1149        } catch (SQLException sqlEx) {
1150            checkAndFireConnectionError(sqlEx);
1151        }
1152    }
1153
1154    /*
1155     * (non-Javadoc)
1156     *
1157     * @see java.sql.CallableStatement#setCharacterStream(java.lang.String,
1158     * java.io.Reader, int)
1159     */
1160    public void setCharacterStream(String parameterName, Reader reader,
1161            int length) throws SQLException {
1162        try {
1163            if (this.wrappedStmt != null) {
1164                ((CallableStatement ) this.wrappedStmt).setCharacterStream(
1165                        parameterName, reader, length);
1166            } else {
1167                throw new SQLException (
1168                        "No operations allowed after statement closed",
1169                        SQLError.SQL_STATE_GENERAL_ERROR);
1170            }
1171        } catch (SQLException sqlEx) {
1172            checkAndFireConnectionError(sqlEx);
1173        }
1174    }
1175
1176    /*
1177     * (non-Javadoc)
1178     *
1179     * @see java.sql.CallableStatement#setDate(java.lang.String, java.sql.Date,
1180     * java.util.Calendar)
1181     */
1182    public void setDate(String parameterName, Date x, Calendar cal)
1183            throws SQLException {
1184        try {
1185            if (this.wrappedStmt != null) {
1186                ((CallableStatement ) this.wrappedStmt).setDate(parameterName,
1187                        x, cal);
1188            } else {
1189                throw new SQLException (
1190                        "No operations allowed after statement closed",
1191                        SQLError.SQL_STATE_GENERAL_ERROR);
1192            }
1193        } catch (SQLException sqlEx) {
1194            checkAndFireConnectionError(sqlEx);
1195        }
1196    }
1197
1198    /*
1199     * (non-Javadoc)
1200     *
1201     * @see java.sql.CallableStatement#setTime(java.lang.String, java.sql.Time,
1202     * java.util.Calendar)
1203     */
1204    public void setTime(String parameterName, Time x, Calendar cal)
1205            throws SQLException {
1206        try {
1207            if (this.wrappedStmt != null) {
1208                ((CallableStatement ) this.wrappedStmt).setTime(parameterName,
1209                        x, cal);
1210            } else {
1211                throw new SQLException (
1212                        "No operations allowed after statement closed",
1213                        SQLError.SQL_STATE_GENERAL_ERROR);
1214            }
1215        } catch (SQLException sqlEx) {
1216            checkAndFireConnectionError(sqlEx);
1217        }
1218    }
1219
1220    /*
1221     * (non-Javadoc)
1222     *
1223     * @see java.sql.CallableStatement#setTimestamp(java.lang.String,
1224     * java.sql.Timestamp, java.util.Calendar)
1225     */
1226    public void setTimestamp(String parameterName, Timestamp x, Calendar cal)
1227            throws SQLException {
1228        try {
1229            if (this.wrappedStmt != null) {
1230                ((CallableStatement ) this.wrappedStmt).setTimestamp(
1231                        parameterName, x, cal);
1232            } else {
1233                throw new SQLException (
1234                        "No operations allowed after statement closed",
1235                        SQLError.SQL_STATE_GENERAL_ERROR);
1236            }
1237        } catch (SQLException sqlEx) {
1238            checkAndFireConnectionError(sqlEx);
1239        }
1240    }
1241
1242    /*
1243     * (non-Javadoc)
1244     *
1245     * @see java.sql.CallableStatement#setNull(java.lang.String, int,
1246     * java.lang.String)
1247     */
1248    public void setNull(String parameterName, int sqlType, String typeName)
1249            throws SQLException {
1250        try {
1251            if (this.wrappedStmt != null) {
1252                ((CallableStatement ) this.wrappedStmt).setNull(parameterName,
1253                        sqlType, typeName);
1254            } else {
1255                throw new SQLException (
1256                        "No operations allowed after statement closed",
1257                        SQLError.SQL_STATE_GENERAL_ERROR);
1258            }
1259        } catch (SQLException sqlEx) {
1260            checkAndFireConnectionError(sqlEx);
1261        }
1262    }
1263
1264    /*
1265     * (non-Javadoc)
1266     *
1267     * @see java.sql.CallableStatement#getString(int)
1268     */
1269    public String getString(String parameterName) throws SQLException {
1270        try {
1271            if (this.wrappedStmt != null) {
1272                return ((CallableStatement ) this.wrappedStmt)
1273                        .getString(parameterName);
1274            } else {
1275                throw new SQLException (
1276                        "No operations allowed after statement closed",
1277                        SQLError.SQL_STATE_GENERAL_ERROR);
1278            }
1279        } catch (SQLException sqlEx) {
1280            checkAndFireConnectionError(sqlEx);
1281        }
1282        return null;
1283    }
1284
1285    /*
1286     * (non-Javadoc)
1287     *
1288     * @see java.sql.CallableStatement#getBoolean(int)
1289     */
1290    public boolean getBoolean(String parameterName) throws SQLException {
1291        try {
1292            if (this.wrappedStmt != null) {
1293                return ((CallableStatement ) this.wrappedStmt)
1294                        .getBoolean(parameterName);
1295            } else {
1296                throw new SQLException (
1297                        "No operations allowed after statement closed",
1298                        SQLError.SQL_STATE_GENERAL_ERROR);
1299            }
1300        } catch (SQLException sqlEx) {
1301            checkAndFireConnectionError(sqlEx);
1302        }
1303
1304        return false;
1305    }
1306
1307    /*
1308     * (non-Javadoc)
1309     *
1310     * @see java.sql.CallableStatement#getByte(int)
1311     */
1312    public byte getByte(String parameterName) throws SQLException {
1313        try {
1314            if (this.wrappedStmt != null) {
1315                return ((CallableStatement ) this.wrappedStmt)
1316                        .getByte(parameterName);
1317            } else {
1318                throw new SQLException (
1319                        "No operations allowed after statement closed",
1320                        SQLError.SQL_STATE_GENERAL_ERROR);
1321            }
1322        } catch (SQLException sqlEx) {
1323            checkAndFireConnectionError(sqlEx);
1324        }
1325
1326        return 0;
1327    }
1328
1329    /*
1330     * (non-Javadoc)
1331     *
1332     * @see java.sql.CallableStatement#getShort(int)
1333     */
1334    public short getShort(String parameterName) throws SQLException {
1335        try {
1336            if (this.wrappedStmt != null) {
1337                return ((CallableStatement ) this.wrappedStmt)
1338                        .getShort(parameterName);
1339            } else {
1340                throw new SQLException (
1341                        "No operations allowed after statement closed",
1342                        SQLError.SQL_STATE_GENERAL_ERROR);
1343            }
1344        } catch (SQLException sqlEx) {
1345            checkAndFireConnectionError(sqlEx);
1346        }
1347
1348        return 0;
1349    }
1350
1351    /*
1352     * (non-Javadoc)
1353     *
1354     * @see java.sql.CallableStatement#getInt(int)
1355     */
1356    public int getInt(String parameterName) throws SQLException {
1357        try {
1358            if (this.wrappedStmt != null) {
1359                return ((CallableStatement ) this.wrappedStmt)
1360                        .getInt(parameterName);
1361            } else {
1362                throw new SQLException (
1363                        "No operations allowed after statement closed",
1364                        SQLError.SQL_STATE_GENERAL_ERROR);
1365            }
1366        } catch (SQLException sqlEx) {
1367            checkAndFireConnectionError(sqlEx);
1368        }
1369
1370        return 0;
1371    }
1372
1373    /*
1374     * (non-Javadoc)
1375     *
1376     * @see java.sql.CallableStatement#getLong(int)
1377     */
1378    public long getLong(String parameterName) throws SQLException {
1379        try {
1380            if (this.wrappedStmt != null) {
1381                return ((CallableStatement ) this.wrappedStmt)
1382                        .getLong(parameterName);
1383            } else {
1384                throw new SQLException (
1385                        "No operations allowed after statement closed",
1386                        SQLError.SQL_STATE_GENERAL_ERROR);
1387            }
1388        } catch (SQLException sqlEx) {
1389            checkAndFireConnectionError(sqlEx);
1390        }
1391
1392        return 0;
1393    }
1394
1395    /*
1396     * (non-Javadoc)
1397     *
1398     * @see java.sql.CallableStatement#getFloat(int)
1399     */
1400    public float getFloat(String parameterName) throws SQLException {
1401        try {
1402            if (this.wrappedStmt != null) {
1403                return ((CallableStatement ) this.wrappedStmt)
1404                        .getFloat(parameterName);
1405            } else {
1406                throw new SQLException (
1407                        "No operations allowed after statement closed",
1408                        SQLError.SQL_STATE_GENERAL_ERROR);
1409            }
1410        } catch (SQLException sqlEx) {
1411            checkAndFireConnectionError(sqlEx);
1412        }
1413
1414        return 0;
1415    }
1416
1417    /*
1418     * (non-Javadoc)
1419     *
1420     * @see java.sql.CallableStatement#getDouble(int)
1421     */
1422    public double getDouble(String parameterName) throws SQLException {
1423        try {
1424            if (this.wrappedStmt != null) {
1425                return ((CallableStatement ) this.wrappedStmt)
1426                        .getDouble(parameterName);
1427            } else {
1428                throw new SQLException (
1429                        "No operations allowed after statement closed",
1430                        SQLError.SQL_STATE_GENERAL_ERROR);
1431            }
1432        } catch (SQLException sqlEx) {
1433            checkAndFireConnectionError(sqlEx);
1434        }
1435
1436        return 0;
1437    }
1438
1439    /*
1440     * (non-Javadoc)
1441     *
1442     * @see java.sql.CallableStatement#getBytes(int)
1443     */
1444    public byte[] getBytes(String parameterName) throws SQLException {
1445        try {
1446            if (this.wrappedStmt != null) {
1447                return ((CallableStatement ) this.wrappedStmt)
1448                        .getBytes(parameterName);
1449            } else {
1450                throw new SQLException (
1451                        "No operations allowed after statement closed",
1452                        SQLError.SQL_STATE_GENERAL_ERROR);
1453            }
1454        } catch (SQLException sqlEx) {
1455            checkAndFireConnectionError(sqlEx);
1456        }
1457
1458        return null;
1459    }
1460
1461    /*
1462     * (non-Javadoc)
1463     *
1464     * @see java.sql.CallableStatement#getDate(int)
1465     */
1466    public Date getDate(String parameterName) throws SQLException {
1467        try {
1468            if (this.wrappedStmt != null) {
1469                return ((CallableStatement ) this.wrappedStmt)
1470                        .getDate(parameterName);
1471            } else {
1472                throw new SQLException (
1473                        "No operations allowed after statement closed",
1474                        SQLError.SQL_STATE_GENERAL_ERROR);
1475            }
1476        } catch (SQLException sqlEx) {
1477            checkAndFireConnectionError(sqlEx);
1478        }
1479
1480        return null;
1481    }
1482
1483    /*
1484     * (non-Javadoc)
1485     *
1486     * @see java.sql.CallableStatement#getTime(int)
1487     */
1488    public Time getTime(String parameterName) throws SQLException {
1489        try {
1490            if (this.wrappedStmt != null) {
1491                return ((CallableStatement ) this.wrappedStmt)
1492                        .getTime(parameterName);
1493            } else {
1494                throw new SQLException (
1495                        "No operations allowed after statement closed",
1496                        SQLError.SQL_STATE_GENERAL_ERROR);
1497            }
1498        } catch (SQLException sqlEx) {
1499            checkAndFireConnectionError(sqlEx);
1500        }
1501
1502        return null;
1503    }
1504
1505    /*
1506     * (non-Javadoc)
1507     *
1508     * @see java.sql.CallableStatement#getTimestamp(int)
1509     */
1510    public Timestamp getTimestamp(String parameterName) throws SQLException {
1511        try {
1512            if (this.wrappedStmt != null) {
1513                return ((CallableStatement ) this.wrappedStmt)
1514                        .getTimestamp(parameterName);
1515            } else {
1516                throw new SQLException (
1517                        "No operations allowed after statement closed",
1518                        SQLError.SQL_STATE_GENERAL_ERROR);
1519            }
1520        } catch (SQLException sqlEx) {
1521            checkAndFireConnectionError(sqlEx);
1522        }
1523
1524        return null;
1525    }
1526
1527    /*
1528     * (non-Javadoc)
1529     *
1530     * @see java.sql.CallableStatement#getObject(int)
1531     */
1532    public Object getObject(String parameterName) throws SQLException {
1533        try {
1534            if (this.wrappedStmt != null) {
1535                return ((CallableStatement ) this.wrappedStmt)
1536                        .getObject(parameterName);
1537            } else {
1538                throw new SQLException (
1539                        "No operations allowed after statement closed",
1540                        SQLError.SQL_STATE_GENERAL_ERROR);
1541            }
1542        } catch (SQLException sqlEx) {
1543            checkAndFireConnectionError(sqlEx);
1544        }
1545
1546        return null;
1547    }
1548
1549    /*
1550     * (non-Javadoc)
1551     *
1552     * @see java.sql.CallableStatement#getBigDecimal(int)
1553     */
1554    public BigDecimal getBigDecimal(String parameterName) throws SQLException {
1555        try {
1556            if (this.wrappedStmt != null) {
1557                return ((CallableStatement ) this.wrappedStmt)
1558                        .getBigDecimal(parameterName);
1559            } else {
1560                throw new SQLException (
1561                        "No operations allowed after statement closed",
1562                        SQLError.SQL_STATE_GENERAL_ERROR);
1563            }
1564        } catch (SQLException sqlEx) {
1565            checkAndFireConnectionError(sqlEx);
1566        }
1567
1568        return null;
1569    }
1570
1571    /*
1572     * (non-Javadoc)
1573     *
1574     * @see java.sql.CallableStatement#getObject(int, java.util.Map)
1575     */
1576    public Object getObject(String parameterName, Map typeMap)
1577            throws SQLException {
1578        try {
1579            if (this.wrappedStmt != null) {
1580                return ((CallableStatement ) this.wrappedStmt).getObject(
1581                        parameterName, typeMap);
1582            } else {
1583                throw new SQLException (
1584                        "No operations allowed after statement closed",
1585                        SQLError.SQL_STATE_GENERAL_ERROR);
1586            }
1587        } catch (SQLException sqlEx) {
1588            checkAndFireConnectionError(sqlEx);
1589        }
1590        return null;
1591    }
1592
1593    /*
1594     * (non-Javadoc)
1595     *
1596     * @see java.sql.CallableStatement#getRef(int)
1597     */
1598    public Ref getRef(String parameterName) throws SQLException {
1599        try {
1600            if (this.wrappedStmt != null) {
1601                return ((CallableStatement ) this.wrappedStmt)
1602                        .getRef(parameterName);
1603            } else {
1604                throw new SQLException (
1605                        "No operations allowed after statement closed",
1606                        SQLError.SQL_STATE_GENERAL_ERROR);
1607            }
1608        } catch (SQLException sqlEx) {
1609            checkAndFireConnectionError(sqlEx);
1610        }
1611
1612        return null;
1613    }
1614
1615    /*
1616     * (non-Javadoc)
1617     *
1618     * @see java.sql.CallableStatement#getBlob(int)
1619     */
1620    public Blob getBlob(String parameterName) throws SQLException {
1621        try {
1622            if (this.wrappedStmt != null) {
1623                return ((CallableStatement ) this.wrappedStmt)
1624                        .getBlob(parameterName);
1625            } else {
1626                throw new SQLException (
1627                        "No operations allowed after statement closed",
1628                        SQLError.SQL_STATE_GENERAL_ERROR);
1629            }
1630        } catch (SQLException sqlEx) {
1631            checkAndFireConnectionError(sqlEx);
1632        }
1633
1634        return null;
1635    }
1636
1637    /*
1638     * (non-Javadoc)
1639     *
1640     * @see java.sql.CallableStatement#getClob(int)
1641     */
1642    public Clob getClob(String parameterName) throws SQLException {
1643        try {
1644            if (this.wrappedStmt != null) {
1645                return ((CallableStatement ) this.wrappedStmt)
1646                        .getClob(parameterName);
1647            } else {
1648                throw new SQLException (
1649                        "No operations allowed after statement closed",
1650                        SQLError.SQL_STATE_GENERAL_ERROR);
1651            }
1652        } catch (SQLException sqlEx) {
1653            checkAndFireConnectionError(sqlEx);
1654        }
1655        return null;
1656    }
1657
1658    /*
1659     * (non-Javadoc)
1660     *
1661     * @see java.sql.CallableStatement#getArray(int)
1662     */
1663    public Array getArray(String parameterName) throws SQLException {
1664        try {
1665            if (this.wrappedStmt != null) {
1666                return ((CallableStatement ) this.wrappedStmt)
1667                        .getArray(parameterName);
1668            } else {
1669                throw new SQLException (
1670                        "No operations allowed after statement closed",
1671                        SQLError.SQL_STATE_GENERAL_ERROR);
1672            }
1673        } catch (SQLException sqlEx) {
1674            checkAndFireConnectionError(sqlEx);
1675        }
1676        return null;
1677    }
1678
1679    /*
1680     * (non-Javadoc)
1681     *
1682     * @see java.sql.CallableStatement#getDate(int, java.util.Calendar)
1683     */
1684    public Date getDate(String parameterName, Calendar cal) throws SQLException {
1685        try {
1686            if (this.wrappedStmt != null) {
1687                return ((CallableStatement ) this.wrappedStmt).getDate(
1688                        parameterName, cal);
1689            } else {
1690                throw new SQLException (
1691                        "No operations allowed after statement closed",
1692                        SQLError.SQL_STATE_GENERAL_ERROR);
1693            }
1694        } catch (SQLException sqlEx) {
1695            checkAndFireConnectionError(sqlEx);
1696        }
1697        return null;
1698    }
1699
1700    /*
1701     * (non-Javadoc)
1702     *
1703     * @see java.sql.CallableStatement#getTime(int, java.util.Calendar)
1704     */
1705    public Time getTime(String parameterName, Calendar cal) throws SQLException {
1706        try {
1707            if (this.wrappedStmt != null) {
1708                return ((CallableStatement ) this.wrappedStmt).getTime(
1709                        parameterName, cal);
1710            } else {
1711                throw new SQLException (
1712                        "No operations allowed after statement closed",
1713                        SQLError.SQL_STATE_GENERAL_ERROR);
1714            }
1715        } catch (SQLException sqlEx) {
1716            checkAndFireConnectionError(sqlEx);
1717        }
1718        return null;
1719    }
1720
1721    /*
1722     * (non-Javadoc)
1723     *
1724     * @see java.sql.CallableStatement#getTimestamp(int, java.util.Calendar)
1725     */
1726    public Timestamp getTimestamp(String parameterName, Calendar cal)
1727            throws SQLException {
1728        try {
1729            if (this.wrappedStmt != null) {
1730                return ((CallableStatement ) this.wrappedStmt).getTimestamp(
1731                        parameterName, cal);
1732            } else {
1733                throw new SQLException (
1734                        "No operations allowed after statement closed",
1735                        SQLError.SQL_STATE_GENERAL_ERROR);
1736            }
1737        } catch (SQLException sqlEx) {
1738            checkAndFireConnectionError(sqlEx);
1739        }
1740        return null;
1741    }
1742
1743    /*
1744     * (non-Javadoc)
1745     *
1746     * @see java.sql.CallableStatement#getURL(java.lang.String)
1747     */
1748    public URL getURL(String parameterName) throws SQLException {
1749        try {
1750            if (this.wrappedStmt != null) {
1751                return ((CallableStatement ) this.wrappedStmt)
1752                        .getURL(parameterName);
1753            } else {
1754                throw new SQLException (
1755                        "No operations allowed after statement closed",
1756                        SQLError.SQL_STATE_GENERAL_ERROR);
1757            }
1758        } catch (SQLException sqlEx) {
1759            checkAndFireConnectionError(sqlEx);
1760        }
1761
1762        return null;
1763    }
1764
1765}
1766

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---