source: Ballon/out/artifacts/geisa_artifact/WEB-INF/lib/mysql-connector-java-5.1.21/src/com/mysql/jdbc/jdbc2/optional/CallableStatementWrapper.java @ 848

Last change on this file since 848 was 766, checked in by npipsl, 11 years ago
File size: 72.8 KB
Line 
1/*
2 Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved.
3 
4
5  The MySQL Connector/J is licensed under the terms of the GPLv2
6  <http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most MySQL Connectors.
7  There are special exceptions to the terms and conditions of the GPLv2 as it is applied to
8  this software, see the FLOSS License Exception
9  <http://www.mysql.com/about/legal/licensing/foss-exception.html>.
10
11  This program is free software; you can redistribute it and/or modify it under the terms
12  of the GNU General Public License as published by the Free Software Foundation; version 2
13  of the License.
14
15  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
16  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
17  See the GNU General Public License for more details.
18
19  You should have received a copy of the GNU General Public License along with this
20  program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth
21  Floor, Boston, MA 02110-1301  USA
22
23
24 */
25
26package com.mysql.jdbc.jdbc2.optional;
27
28import java.io.InputStream;
29import java.io.Reader;
30import java.lang.reflect.Constructor;
31import java.math.BigDecimal;
32import java.net.URL;
33import java.sql.Array;
34import java.sql.Blob;
35import java.sql.CallableStatement;
36import java.sql.Clob;
37import java.sql.Date;
38import java.sql.Ref;
39import java.sql.SQLException;
40import java.sql.Time;
41import java.sql.Timestamp;
42import java.util.Calendar;
43import java.util.Map;
44
45import com.mysql.jdbc.SQLError;
46import com.mysql.jdbc.Util;
47
48/**
49 * Wraps callable statements created by pooled connections.
50 *
51 * @version $Id: CallableStatementWrapper.java,v 1.1.2.1 2005/05/13 18:58:38
52 *          mmatthews Exp $
53 */
54public class CallableStatementWrapper extends PreparedStatementWrapper
55                implements CallableStatement {
56
57        private static final Constructor<?> JDBC_4_CALLABLE_STATEMENT_WRAPPER_CTOR;
58       
59        static {
60                if (Util.isJdbc4()) {
61                        try {
62                                JDBC_4_CALLABLE_STATEMENT_WRAPPER_CTOR = Class.forName(
63                                                "com.mysql.jdbc.jdbc2.optional.JDBC4CallableStatementWrapper").getConstructor(
64                                                new Class[] { ConnectionWrapper.class, 
65                                                                MysqlPooledConnection.class, 
66                                                                CallableStatement.class });
67                        } catch (SecurityException e) {
68                                throw new RuntimeException(e);
69                        } catch (NoSuchMethodException e) {
70                                throw new RuntimeException(e);
71                        } catch (ClassNotFoundException e) {
72                                throw new RuntimeException(e);
73                        }
74                } else {
75                        JDBC_4_CALLABLE_STATEMENT_WRAPPER_CTOR = null;
76                }
77        }
78       
79        protected static CallableStatementWrapper getInstance(ConnectionWrapper c, 
80                        MysqlPooledConnection conn,
81                        CallableStatement toWrap) throws SQLException {
82                if (!Util.isJdbc4()) {
83                        return new CallableStatementWrapper(c, 
84                                        conn, toWrap);
85                }
86
87                return (CallableStatementWrapper) Util.handleNewInstance(
88                                JDBC_4_CALLABLE_STATEMENT_WRAPPER_CTOR,
89                                new Object[] {c, 
90                                                conn, toWrap }, conn.getExceptionInterceptor());
91        }
92       
93       
94       
95        /**
96         * @param c
97         * @param conn
98         * @param toWrap
99         */
100        public CallableStatementWrapper(ConnectionWrapper c,
101                        MysqlPooledConnection conn, CallableStatement toWrap) {
102                super(c, conn, toWrap);
103        }
104
105        /*
106         * (non-Javadoc)
107         *
108         * @see java.sql.CallableStatement#registerOutParameter(int, int)
109         */
110        public void registerOutParameter(int parameterIndex, int sqlType)
111                        throws SQLException {
112                try {
113                        if (this.wrappedStmt != null) {
114                                ((CallableStatement) this.wrappedStmt).registerOutParameter(
115                                                parameterIndex, sqlType);
116                        } else {
117                                throw SQLError.createSQLException(
118                                                "No operations allowed after statement closed",
119                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
120                        }
121                } catch (SQLException sqlEx) {
122                        checkAndFireConnectionError(sqlEx);
123                }
124        }
125
126        /*
127         * (non-Javadoc)
128         *
129         * @see java.sql.CallableStatement#registerOutParameter(int, int, int)
130         */
131        public void registerOutParameter(int parameterIndex, int sqlType, int scale)
132                        throws SQLException {
133                try {
134                        if (this.wrappedStmt != null) {
135                                ((CallableStatement) this.wrappedStmt).registerOutParameter(
136                                                parameterIndex, sqlType, scale);
137                        } else {
138                                throw SQLError.createSQLException(
139                                                "No operations allowed after statement closed",
140                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
141                        }
142                } catch (SQLException sqlEx) {
143                        checkAndFireConnectionError(sqlEx);
144                }
145        }
146
147        /*
148         * (non-Javadoc)
149         *
150         * @see java.sql.CallableStatement#wasNull()
151         */
152        public boolean wasNull() throws SQLException {
153                try {
154                        if (this.wrappedStmt != null) {
155                                return ((CallableStatement) this.wrappedStmt).wasNull();
156                        }
157                        throw SQLError.createSQLException(
158                                "No operations allowed after statement closed",
159                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
160
161                } catch (SQLException sqlEx) {
162                        checkAndFireConnectionError(sqlEx);
163                }
164
165                return false;
166        }
167
168        /*
169         * (non-Javadoc)
170         *
171         * @see java.sql.CallableStatement#getString(int)
172         */
173        public String getString(int parameterIndex) throws SQLException {
174                try {
175                        if (this.wrappedStmt != null) {
176                                return ((CallableStatement) this.wrappedStmt)
177                                                .getString(parameterIndex);
178                        }
179                        throw SQLError.createSQLException(
180                                "No operations allowed after statement closed",
181                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
182
183                } catch (SQLException sqlEx) {
184                        checkAndFireConnectionError(sqlEx);
185                }
186                return null;
187        }
188
189        /*
190         * (non-Javadoc)
191         *
192         * @see java.sql.CallableStatement#getBoolean(int)
193         */
194        public boolean getBoolean(int parameterIndex) throws SQLException {
195                try {
196                        if (this.wrappedStmt != null) {
197                                return ((CallableStatement) this.wrappedStmt)
198                                                .getBoolean(parameterIndex);
199                        }
200                        throw SQLError.createSQLException(
201                                "No operations allowed after statement closed",
202                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
203
204                } catch (SQLException sqlEx) {
205                        checkAndFireConnectionError(sqlEx);
206                }
207
208                return false;
209        }
210
211        /*
212         * (non-Javadoc)
213         *
214         * @see java.sql.CallableStatement#getByte(int)
215         */
216        public byte getByte(int parameterIndex) throws SQLException {
217                try {
218                        if (this.wrappedStmt != null) {
219                                return ((CallableStatement) this.wrappedStmt)
220                                                .getByte(parameterIndex);
221                        }
222                        throw SQLError.createSQLException(
223                                "No operations allowed after statement closed",
224                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
225
226                } catch (SQLException sqlEx) {
227                        checkAndFireConnectionError(sqlEx);
228                }
229
230                return 0;
231        }
232
233        /*
234         * (non-Javadoc)
235         *
236         * @see java.sql.CallableStatement#getShort(int)
237         */
238        public short getShort(int parameterIndex) throws SQLException {
239                try {
240                        if (this.wrappedStmt != null) {
241                                return ((CallableStatement) this.wrappedStmt)
242                                                .getShort(parameterIndex);
243                        }
244                        throw SQLError.createSQLException(
245                                "No operations allowed after statement closed",
246                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
247
248                } catch (SQLException sqlEx) {
249                        checkAndFireConnectionError(sqlEx);
250                }
251
252                return 0;
253        }
254
255        /*
256         * (non-Javadoc)
257         *
258         * @see java.sql.CallableStatement#getInt(int)
259         */
260        public int getInt(int parameterIndex) throws SQLException {
261                try {
262                        if (this.wrappedStmt != null) {
263                                return ((CallableStatement) this.wrappedStmt)
264                                                .getInt(parameterIndex);
265                        }
266                        throw SQLError.createSQLException(
267                                "No operations allowed after statement closed",
268                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
269
270                } catch (SQLException sqlEx) {
271                        checkAndFireConnectionError(sqlEx);
272                }
273
274                return 0;
275        }
276
277        /*
278         * (non-Javadoc)
279         *
280         * @see java.sql.CallableStatement#getLong(int)
281         */
282        public long getLong(int parameterIndex) throws SQLException {
283                try {
284                        if (this.wrappedStmt != null) {
285                                return ((CallableStatement) this.wrappedStmt)
286                                                .getLong(parameterIndex);
287                        }
288                        throw SQLError.createSQLException(
289                                "No operations allowed after statement closed",
290                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
291
292                } catch (SQLException sqlEx) {
293                        checkAndFireConnectionError(sqlEx);
294                }
295
296                return 0;
297        }
298
299        /*
300         * (non-Javadoc)
301         *
302         * @see java.sql.CallableStatement#getFloat(int)
303         */
304        public float getFloat(int parameterIndex) throws SQLException {
305                try {
306                        if (this.wrappedStmt != null) {
307                                return ((CallableStatement) this.wrappedStmt)
308                                                .getFloat(parameterIndex);
309                        }
310                        throw SQLError.createSQLException(
311                                "No operations allowed after statement closed",
312                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
313
314                } catch (SQLException sqlEx) {
315                        checkAndFireConnectionError(sqlEx);
316                }
317
318                return 0;
319        }
320
321        /*
322         * (non-Javadoc)
323         *
324         * @see java.sql.CallableStatement#getDouble(int)
325         */
326        public double getDouble(int parameterIndex) throws SQLException {
327                try {
328                        if (this.wrappedStmt != null) {
329                                return ((CallableStatement) this.wrappedStmt)
330                                                .getDouble(parameterIndex);
331                        }
332                        throw SQLError.createSQLException(
333                                "No operations allowed after statement closed",
334                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
335
336                } catch (SQLException sqlEx) {
337                        checkAndFireConnectionError(sqlEx);
338                }
339
340                return 0;
341        }
342
343        /*
344         * (non-Javadoc)
345         *
346         * @see java.sql.CallableStatement#getBigDecimal(int, int)
347         */
348        public BigDecimal getBigDecimal(int parameterIndex, int scale)
349                        throws SQLException {
350                try {
351                        if (this.wrappedStmt != null) {
352                                return ((CallableStatement) this.wrappedStmt).getBigDecimal(
353                                                parameterIndex, scale);
354                        }
355                        throw SQLError.createSQLException(
356                                "No operations allowed after statement closed",
357                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
358
359                } catch (SQLException sqlEx) {
360                        checkAndFireConnectionError(sqlEx);
361                }
362
363                return null;
364        }
365
366        /*
367         * (non-Javadoc)
368         *
369         * @see java.sql.CallableStatement#getBytes(int)
370         */
371        public byte[] getBytes(int parameterIndex) throws SQLException {
372                try {
373                        if (this.wrappedStmt != null) {
374                                return ((CallableStatement) this.wrappedStmt)
375                                                .getBytes(parameterIndex);
376                        }
377                        throw SQLError.createSQLException(
378                                "No operations allowed after statement closed",
379                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
380
381                } catch (SQLException sqlEx) {
382                        checkAndFireConnectionError(sqlEx);
383                }
384
385                return null;
386        }
387
388        /*
389         * (non-Javadoc)
390         *
391         * @see java.sql.CallableStatement#getDate(int)
392         */
393        public Date getDate(int parameterIndex) throws SQLException {
394                try {
395                        if (this.wrappedStmt != null) {
396                                return ((CallableStatement) this.wrappedStmt)
397                                                .getDate(parameterIndex);
398                        }
399                        throw SQLError.createSQLException(
400                                "No operations allowed after statement closed",
401                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
402
403                } catch (SQLException sqlEx) {
404                        checkAndFireConnectionError(sqlEx);
405                }
406
407                return null;
408        }
409
410        /*
411         * (non-Javadoc)
412         *
413         * @see java.sql.CallableStatement#getTime(int)
414         */
415        public Time getTime(int parameterIndex) throws SQLException {
416                try {
417                        if (this.wrappedStmt != null) {
418                                return ((CallableStatement) this.wrappedStmt)
419                                                .getTime(parameterIndex);
420                        }
421                        throw SQLError.createSQLException(
422                                "No operations allowed after statement closed",
423                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
424
425                } catch (SQLException sqlEx) {
426                        checkAndFireConnectionError(sqlEx);
427                }
428
429                return null;
430        }
431
432        /*
433         * (non-Javadoc)
434         *
435         * @see java.sql.CallableStatement#getTimestamp(int)
436         */
437        public Timestamp getTimestamp(int parameterIndex) throws SQLException {
438                try {
439                        if (this.wrappedStmt != null) {
440                                return ((CallableStatement) this.wrappedStmt)
441                                                .getTimestamp(parameterIndex);
442                        }
443                        throw SQLError.createSQLException(
444                                "No operations allowed after statement closed",
445                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
446
447                } catch (SQLException sqlEx) {
448                        checkAndFireConnectionError(sqlEx);
449                }
450
451                return null;
452        }
453
454        /*
455         * (non-Javadoc)
456         *
457         * @see java.sql.CallableStatement#getObject(int)
458         */
459        public Object getObject(int parameterIndex) throws SQLException {
460                try {
461                        if (this.wrappedStmt != null) {
462                                return ((CallableStatement) this.wrappedStmt)
463                                                .getObject(parameterIndex);
464                        }
465                        throw SQLError.createSQLException(
466                                "No operations allowed after statement closed",
467                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
468
469                } catch (SQLException sqlEx) {
470                        checkAndFireConnectionError(sqlEx);
471                }
472
473                return null;
474        }
475
476        /*
477         * (non-Javadoc)
478         *
479         * @see java.sql.CallableStatement#getBigDecimal(int)
480         */
481        public BigDecimal getBigDecimal(int parameterIndex) throws SQLException {
482                try {
483                        if (this.wrappedStmt != null) {
484                                return ((CallableStatement) this.wrappedStmt)
485                                                .getBigDecimal(parameterIndex);
486                        }
487                        throw SQLError.createSQLException(
488                                "No operations allowed after statement closed",
489                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
490
491                } catch (SQLException sqlEx) {
492                        checkAndFireConnectionError(sqlEx);
493                }
494
495                return null;
496        }
497
498        /*
499         * (non-Javadoc)
500         *
501         * @see java.sql.CallableStatement#getObject(int, java.util.Map)
502         */
503        public Object getObject(int parameterIndex, Map<String, Class<?>> typeMap)
504                        throws SQLException {
505                try {
506                        if (this.wrappedStmt != null) {
507                                return ((CallableStatement) this.wrappedStmt).getObject(
508                                                parameterIndex, typeMap);
509                        }
510                        throw SQLError.createSQLException(
511                                "No operations allowed after statement closed",
512                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
513
514                } catch (SQLException sqlEx) {
515                        checkAndFireConnectionError(sqlEx);
516                }
517                return null;
518        }
519
520        /*
521         * (non-Javadoc)
522         *
523         * @see java.sql.CallableStatement#getRef(int)
524         */
525        public Ref getRef(int parameterIndex) throws SQLException {
526                try {
527                        if (this.wrappedStmt != null) {
528                                return ((CallableStatement) this.wrappedStmt)
529                                                .getRef(parameterIndex);
530                        }
531                        throw SQLError.createSQLException(
532                                "No operations allowed after statement closed",
533                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
534
535                } catch (SQLException sqlEx) {
536                        checkAndFireConnectionError(sqlEx);
537                }
538
539                return null;
540        }
541
542        /*
543         * (non-Javadoc)
544         *
545         * @see java.sql.CallableStatement#getBlob(int)
546         */
547        public Blob getBlob(int parameterIndex) throws SQLException {
548                try {
549                        if (this.wrappedStmt != null) {
550                                return ((CallableStatement) this.wrappedStmt)
551                                                .getBlob(parameterIndex);
552                        }
553                        throw SQLError.createSQLException(
554                                "No operations allowed after statement closed",
555                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
556
557                } catch (SQLException sqlEx) {
558                        checkAndFireConnectionError(sqlEx);
559                }
560
561                return null;
562        }
563
564        /*
565         * (non-Javadoc)
566         *
567         * @see java.sql.CallableStatement#getClob(int)
568         */
569        public Clob getClob(int parameterIndex) throws SQLException {
570                try {
571                        if (this.wrappedStmt != null) {
572                                return ((CallableStatement) this.wrappedStmt)
573                                                .getClob(parameterIndex);
574                        }
575                        throw SQLError.createSQLException(
576                                "No operations allowed after statement closed",
577                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
578
579                } catch (SQLException sqlEx) {
580                        checkAndFireConnectionError(sqlEx);
581                }
582                return null;
583        }
584
585        /*
586         * (non-Javadoc)
587         *
588         * @see java.sql.CallableStatement#getArray(int)
589         */
590        public Array getArray(int parameterIndex) throws SQLException {
591                try {
592                        if (this.wrappedStmt != null) {
593                                return ((CallableStatement) this.wrappedStmt)
594                                                .getArray(parameterIndex);
595                        }
596                        throw SQLError.createSQLException(
597                                "No operations allowed after statement closed",
598                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
599
600                } catch (SQLException sqlEx) {
601                        checkAndFireConnectionError(sqlEx);
602                }
603                return null;
604        }
605
606        /*
607         * (non-Javadoc)
608         *
609         * @see java.sql.CallableStatement#getDate(int, java.util.Calendar)
610         */
611        public Date getDate(int parameterIndex, Calendar cal) throws SQLException {
612                try {
613                        if (this.wrappedStmt != null) {
614                                return ((CallableStatement) this.wrappedStmt).getDate(
615                                                parameterIndex, cal);
616                        }
617                        throw SQLError.createSQLException(
618                                "No operations allowed after statement closed",
619                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
620
621                } catch (SQLException sqlEx) {
622                        checkAndFireConnectionError(sqlEx);
623                }
624                return null;
625        }
626
627        /*
628         * (non-Javadoc)
629         *
630         * @see java.sql.CallableStatement#getTime(int, java.util.Calendar)
631         */
632        public Time getTime(int parameterIndex, Calendar cal) throws SQLException {
633                try {
634                        if (this.wrappedStmt != null) {
635                                return ((CallableStatement) this.wrappedStmt).getTime(
636                                                parameterIndex, cal);
637                        }
638                        throw SQLError.createSQLException(
639                                "No operations allowed after statement closed",
640                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
641
642                } catch (SQLException sqlEx) {
643                        checkAndFireConnectionError(sqlEx);
644                }
645                return null;
646        }
647
648        /*
649         * (non-Javadoc)
650         *
651         * @see java.sql.CallableStatement#getTimestamp(int, java.util.Calendar)
652         */
653        public Timestamp getTimestamp(int parameterIndex, Calendar cal)
654                        throws SQLException {
655                try {
656                        if (this.wrappedStmt != null) {
657                                return ((CallableStatement) this.wrappedStmt).getTimestamp(
658                                                parameterIndex, cal);
659                        }
660                        throw SQLError.createSQLException(
661                                "No operations allowed after statement closed",
662                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
663
664                } catch (SQLException sqlEx) {
665                        checkAndFireConnectionError(sqlEx);
666                }
667                return null;
668        }
669
670        /*
671         * (non-Javadoc)
672         *
673         * @see java.sql.CallableStatement#registerOutParameter(int, int,
674         *      java.lang.String)
675         */
676        public void registerOutParameter(int paramIndex, int sqlType,
677                        String typeName) throws SQLException {
678                try {
679                        if (this.wrappedStmt != null) {
680                                ((CallableStatement) this.wrappedStmt).registerOutParameter(
681                                                paramIndex, sqlType, typeName);
682                        } else {
683                                throw SQLError.createSQLException(
684                                                "No operations allowed after statement closed",
685                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
686                        }
687                } catch (SQLException sqlEx) {
688                        checkAndFireConnectionError(sqlEx);
689                }
690        }
691
692        /*
693         * (non-Javadoc)
694         *
695         * @see java.sql.CallableStatement#registerOutParameter(java.lang.String,
696         *      int)
697         */
698        public void registerOutParameter(String parameterName, int sqlType)
699                        throws SQLException {
700                try {
701                        if (this.wrappedStmt != null) {
702                                ((CallableStatement) this.wrappedStmt).registerOutParameter(
703                                                parameterName, sqlType);
704                        } else {
705                                throw SQLError.createSQLException(
706                                                "No operations allowed after statement closed",
707                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
708                        }
709                } catch (SQLException sqlEx) {
710                        checkAndFireConnectionError(sqlEx);
711                }
712        }
713
714        /*
715         * (non-Javadoc)
716         *
717         * @see java.sql.CallableStatement#registerOutParameter(java.lang.String,
718         *      int, int)
719         */
720        public void registerOutParameter(String parameterName, int sqlType,
721                        int scale) throws SQLException {
722                try {
723                        if (this.wrappedStmt != null) {
724                                ((CallableStatement) this.wrappedStmt).registerOutParameter(
725                                                parameterName, sqlType, scale);
726                        } else {
727                                throw SQLError.createSQLException(
728                                                "No operations allowed after statement closed",
729                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
730                        }
731                } catch (SQLException sqlEx) {
732                        checkAndFireConnectionError(sqlEx);
733                }
734        }
735
736        /*
737         * (non-Javadoc)
738         *
739         * @see java.sql.CallableStatement#registerOutParameter(java.lang.String,
740         *      int, java.lang.String)
741         */
742        public void registerOutParameter(String parameterName, int sqlType,
743                        String typeName) throws SQLException {
744                try {
745                        if (this.wrappedStmt != null) {
746                                ((CallableStatement) this.wrappedStmt).registerOutParameter(
747                                                parameterName, sqlType, typeName);
748                        } else {
749                                throw SQLError.createSQLException(
750                                                "No operations allowed after statement closed",
751                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
752                        }
753                } catch (SQLException sqlEx) {
754                        checkAndFireConnectionError(sqlEx);
755                }
756        }
757
758        /*
759         * (non-Javadoc)
760         *
761         * @see java.sql.CallableStatement#getURL(int)
762         */
763        public URL getURL(int parameterIndex) throws SQLException {
764                try {
765                        if (this.wrappedStmt != null) {
766                                return ((CallableStatement) this.wrappedStmt)
767                                                .getURL(parameterIndex);
768                        }
769                        throw SQLError.createSQLException(
770                                "No operations allowed after statement closed",
771                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
772
773                } catch (SQLException sqlEx) {
774                        checkAndFireConnectionError(sqlEx);
775                }
776
777                return null;
778        }
779
780        /*
781         * (non-Javadoc)
782         *
783         * @see java.sql.CallableStatement#setURL(java.lang.String, java.net.URL)
784         */
785        public void setURL(String parameterName, URL val) throws SQLException {
786                try {
787                        if (this.wrappedStmt != null) {
788                                ((CallableStatement) this.wrappedStmt).setURL(parameterName,
789                                                val);
790                        } else {
791                                throw SQLError.createSQLException(
792                                                "No operations allowed after statement closed",
793                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
794                        }
795                } catch (SQLException sqlEx) {
796                        checkAndFireConnectionError(sqlEx);
797                }
798        }
799
800        /*
801         * (non-Javadoc)
802         *
803         * @see java.sql.CallableStatement#setNull(java.lang.String, int)
804         */
805        public void setNull(String parameterName, int sqlType) throws SQLException {
806                try {
807                        if (this.wrappedStmt != null) {
808                                ((CallableStatement) this.wrappedStmt).setNull(parameterName,
809                                                sqlType);
810                        } else {
811                                throw SQLError.createSQLException(
812                                                "No operations allowed after statement closed",
813                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
814                        }
815                } catch (SQLException sqlEx) {
816                        checkAndFireConnectionError(sqlEx);
817                }
818        }
819
820        /*
821         * (non-Javadoc)
822         *
823         * @see java.sql.CallableStatement#setBoolean(java.lang.String, boolean)
824         */
825        public void setBoolean(String parameterName, boolean x) throws SQLException {
826                try {
827                        if (this.wrappedStmt != null) {
828                                ((CallableStatement) this.wrappedStmt).setBoolean(
829                                                parameterName, x);
830                        } else {
831                                throw SQLError.createSQLException(
832                                                "No operations allowed after statement closed",
833                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
834                        }
835                } catch (SQLException sqlEx) {
836                        checkAndFireConnectionError(sqlEx);
837                }
838        }
839
840        /*
841         * (non-Javadoc)
842         *
843         * @see java.sql.CallableStatement#setByte(java.lang.String, byte)
844         */
845        public void setByte(String parameterName, byte x) throws SQLException {
846                try {
847                        if (this.wrappedStmt != null) {
848                                ((CallableStatement) this.wrappedStmt)
849                                                .setByte(parameterName, x);
850                        } else {
851                                throw SQLError.createSQLException(
852                                                "No operations allowed after statement closed",
853                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
854                        }
855                } catch (SQLException sqlEx) {
856                        checkAndFireConnectionError(sqlEx);
857                }
858        }
859
860        /*
861         * (non-Javadoc)
862         *
863         * @see java.sql.CallableStatement#setShort(java.lang.String, short)
864         */
865        public void setShort(String parameterName, short x) throws SQLException {
866                try {
867                        if (this.wrappedStmt != null) {
868                                ((CallableStatement) this.wrappedStmt).setShort(parameterName,
869                                                x);
870                        } else {
871                                throw SQLError.createSQLException(
872                                                "No operations allowed after statement closed",
873                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
874                        }
875                } catch (SQLException sqlEx) {
876                        checkAndFireConnectionError(sqlEx);
877                }
878        }
879
880        /*
881         * (non-Javadoc)
882         *
883         * @see java.sql.CallableStatement#setInt(java.lang.String, int)
884         */
885        public void setInt(String parameterName, int x) throws SQLException {
886                try {
887                        if (this.wrappedStmt != null) {
888                                ((CallableStatement) this.wrappedStmt).setInt(parameterName, x);
889                        } else {
890                                throw SQLError.createSQLException(
891                                                "No operations allowed after statement closed",
892                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
893                        }
894                } catch (SQLException sqlEx) {
895                        checkAndFireConnectionError(sqlEx);
896                }
897        }
898
899        /*
900         * (non-Javadoc)
901         *
902         * @see java.sql.CallableStatement#setLong(java.lang.String, long)
903         */
904        public void setLong(String parameterName, long x) throws SQLException {
905                try {
906                        if (this.wrappedStmt != null) {
907                                ((CallableStatement) this.wrappedStmt)
908                                                .setLong(parameterName, x);
909                        } else {
910                                throw SQLError.createSQLException(
911                                                "No operations allowed after statement closed",
912                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
913                        }
914                } catch (SQLException sqlEx) {
915                        checkAndFireConnectionError(sqlEx);
916                }
917        }
918
919        /*
920         * (non-Javadoc)
921         *
922         * @see java.sql.CallableStatement#setFloat(java.lang.String, float)
923         */
924        public void setFloat(String parameterName, float x) throws SQLException {
925                try {
926                        if (this.wrappedStmt != null) {
927                                ((CallableStatement) this.wrappedStmt).setFloat(parameterName,
928                                                x);
929                        } else {
930                                throw SQLError.createSQLException(
931                                                "No operations allowed after statement closed",
932                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
933                        }
934                } catch (SQLException sqlEx) {
935                        checkAndFireConnectionError(sqlEx);
936                }
937        }
938
939        /*
940         * (non-Javadoc)
941         *
942         * @see java.sql.CallableStatement#setDouble(java.lang.String, double)
943         */
944        public void setDouble(String parameterName, double x) throws SQLException {
945                try {
946                        if (this.wrappedStmt != null) {
947                                ((CallableStatement) this.wrappedStmt).setDouble(parameterName,
948                                                x);
949                        } else {
950                                throw SQLError.createSQLException(
951                                                "No operations allowed after statement closed",
952                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
953                        }
954                } catch (SQLException sqlEx) {
955                        checkAndFireConnectionError(sqlEx);
956                }
957        }
958
959        /*
960         * (non-Javadoc)
961         *
962         * @see java.sql.CallableStatement#setBigDecimal(java.lang.String,
963         *      java.math.BigDecimal)
964         */
965        public void setBigDecimal(String parameterName, BigDecimal x)
966                        throws SQLException {
967                try {
968                        if (this.wrappedStmt != null) {
969                                ((CallableStatement) this.wrappedStmt).setBigDecimal(
970                                                parameterName, x);
971                        } else {
972                                throw SQLError.createSQLException(
973                                                "No operations allowed after statement closed",
974                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
975                        }
976                } catch (SQLException sqlEx) {
977                        checkAndFireConnectionError(sqlEx);
978                }
979        }
980
981        /*
982         * (non-Javadoc)
983         *
984         * @see java.sql.CallableStatement#setString(java.lang.String,
985         *      java.lang.String)
986         */
987        public void setString(String parameterName, String x) throws SQLException {
988                try {
989                        if (this.wrappedStmt != null) {
990                                ((CallableStatement) this.wrappedStmt).setString(parameterName,
991                                                x);
992                        } else {
993                                throw SQLError.createSQLException(
994                                                "No operations allowed after statement closed",
995                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
996                        }
997                } catch (SQLException sqlEx) {
998                        checkAndFireConnectionError(sqlEx);
999                }
1000        }
1001
1002        /*
1003         * (non-Javadoc)
1004         *
1005         * @see java.sql.CallableStatement#setBytes(java.lang.String, byte[])
1006         */
1007        public void setBytes(String parameterName, byte[] x) throws SQLException {
1008                try {
1009                        if (this.wrappedStmt != null) {
1010                                ((CallableStatement) this.wrappedStmt).setBytes(parameterName,
1011                                                x);
1012                        } else {
1013                                throw SQLError.createSQLException(
1014                                                "No operations allowed after statement closed",
1015                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1016                        }
1017                } catch (SQLException sqlEx) {
1018                        checkAndFireConnectionError(sqlEx);
1019                }
1020        }
1021
1022        /*
1023         * (non-Javadoc)
1024         *
1025         * @see java.sql.CallableStatement#setDate(java.lang.String, java.sql.Date)
1026         */
1027        public void setDate(String parameterName, Date x) throws SQLException {
1028                try {
1029                        if (this.wrappedStmt != null) {
1030                                ((CallableStatement) this.wrappedStmt)
1031                                                .setDate(parameterName, x);
1032                        } else {
1033                                throw SQLError.createSQLException(
1034                                                "No operations allowed after statement closed",
1035                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1036                        }
1037                } catch (SQLException sqlEx) {
1038                        checkAndFireConnectionError(sqlEx);
1039                }
1040        }
1041
1042        /*
1043         * (non-Javadoc)
1044         *
1045         * @see java.sql.CallableStatement#setTime(java.lang.String, java.sql.Time)
1046         */
1047        public void setTime(String parameterName, Time x) throws SQLException {
1048                try {
1049                        if (this.wrappedStmt != null) {
1050                                ((CallableStatement) this.wrappedStmt)
1051                                                .setTime(parameterName, x);
1052                        } else {
1053                                throw SQLError.createSQLException(
1054                                                "No operations allowed after statement closed",
1055                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1056                        }
1057                } catch (SQLException sqlEx) {
1058                        checkAndFireConnectionError(sqlEx);
1059                }
1060        }
1061
1062        /*
1063         * (non-Javadoc)
1064         *
1065         * @see java.sql.CallableStatement#setTimestamp(java.lang.String,
1066         *      java.sql.Timestamp)
1067         */
1068        public void setTimestamp(String parameterName, Timestamp x)
1069                        throws SQLException {
1070                try {
1071                        if (this.wrappedStmt != null) {
1072                                ((CallableStatement) this.wrappedStmt).setTimestamp(
1073                                                parameterName, x);
1074                        } else {
1075                                throw SQLError.createSQLException(
1076                                                "No operations allowed after statement closed",
1077                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1078                        }
1079                } catch (SQLException sqlEx) {
1080                        checkAndFireConnectionError(sqlEx);
1081                }
1082        }
1083
1084        /*
1085         * (non-Javadoc)
1086         *
1087         * @see java.sql.CallableStatement#setAsciiStream(java.lang.String,
1088         *      java.io.InputStream, int)
1089         */
1090        public void setAsciiStream(String parameterName, InputStream x, int length)
1091                        throws SQLException {
1092                try {
1093                        if (this.wrappedStmt != null) {
1094                                ((CallableStatement) this.wrappedStmt).setAsciiStream(
1095                                                parameterName, x, length);
1096                        } else {
1097                                throw SQLError.createSQLException(
1098                                                "No operations allowed after statement closed",
1099                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1100                        }
1101                } catch (SQLException sqlEx) {
1102                        checkAndFireConnectionError(sqlEx);
1103                }
1104
1105        }
1106
1107        /*
1108         * (non-Javadoc)
1109         *
1110         * @see java.sql.CallableStatement#setBinaryStream(java.lang.String,
1111         *      java.io.InputStream, int)
1112         */
1113        public void setBinaryStream(String parameterName, InputStream x, int length)
1114                        throws SQLException {
1115                try {
1116                        if (this.wrappedStmt != null) {
1117                                ((CallableStatement) this.wrappedStmt).setBinaryStream(
1118                                                parameterName, x, length);
1119                        } else {
1120                                throw SQLError.createSQLException(
1121                                                "No operations allowed after statement closed",
1122                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1123                        }
1124                } catch (SQLException sqlEx) {
1125                        checkAndFireConnectionError(sqlEx);
1126                }
1127        }
1128
1129        /*
1130         * (non-Javadoc)
1131         *
1132         * @see java.sql.CallableStatement#setObject(java.lang.String,
1133         *      java.lang.Object, int, int)
1134         */
1135        public void setObject(String parameterName, Object x, int targetSqlType,
1136                        int scale) throws SQLException {
1137                try {
1138                        if (this.wrappedStmt != null) {
1139                                ((CallableStatement) this.wrappedStmt).setObject(parameterName,
1140                                                x, targetSqlType, scale);
1141                        } else {
1142                                throw SQLError.createSQLException(
1143                                                "No operations allowed after statement closed",
1144                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1145                        }
1146                } catch (SQLException sqlEx) {
1147                        checkAndFireConnectionError(sqlEx);
1148                }
1149        }
1150
1151        /*
1152         * (non-Javadoc)
1153         *
1154         * @see java.sql.CallableStatement#setObject(java.lang.String,
1155         *      java.lang.Object, int)
1156         */
1157        public void setObject(String parameterName, Object x, int targetSqlType)
1158                        throws SQLException {
1159                try {
1160                        if (this.wrappedStmt != null) {
1161                                ((CallableStatement) this.wrappedStmt).setObject(parameterName,
1162                                                x, targetSqlType);
1163                        } else {
1164                                throw SQLError.createSQLException(
1165                                                "No operations allowed after statement closed",
1166                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1167                        }
1168                } catch (SQLException sqlEx) {
1169                        checkAndFireConnectionError(sqlEx);
1170                }
1171        }
1172
1173        /*
1174         * (non-Javadoc)
1175         *
1176         * @see java.sql.CallableStatement#setObject(java.lang.String,
1177         *      java.lang.Object)
1178         */
1179        public void setObject(String parameterName, Object x) throws SQLException {
1180                try {
1181                        if (this.wrappedStmt != null) {
1182                                ((CallableStatement) this.wrappedStmt).setObject(parameterName,
1183                                                x);
1184                        } else {
1185                                throw SQLError.createSQLException(
1186                                                "No operations allowed after statement closed",
1187                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1188                        }
1189                } catch (SQLException sqlEx) {
1190                        checkAndFireConnectionError(sqlEx);
1191                }
1192        }
1193
1194        /*
1195         * (non-Javadoc)
1196         *
1197         * @see java.sql.CallableStatement#setCharacterStream(java.lang.String,
1198         *      java.io.Reader, int)
1199         */
1200        public void setCharacterStream(String parameterName, Reader reader,
1201                        int length) throws SQLException {
1202                try {
1203                        if (this.wrappedStmt != null) {
1204                                ((CallableStatement) this.wrappedStmt).setCharacterStream(
1205                                                parameterName, reader, length);
1206                        } else {
1207                                throw SQLError.createSQLException(
1208                                                "No operations allowed after statement closed",
1209                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1210                        }
1211                } catch (SQLException sqlEx) {
1212                        checkAndFireConnectionError(sqlEx);
1213                }
1214        }
1215
1216        /*
1217         * (non-Javadoc)
1218         *
1219         * @see java.sql.CallableStatement#setDate(java.lang.String, java.sql.Date,
1220         *      java.util.Calendar)
1221         */
1222        public void setDate(String parameterName, Date x, Calendar cal)
1223                        throws SQLException {
1224                try {
1225                        if (this.wrappedStmt != null) {
1226                                ((CallableStatement) this.wrappedStmt).setDate(parameterName,
1227                                                x, cal);
1228                        } else {
1229                                throw SQLError.createSQLException(
1230                                                "No operations allowed after statement closed",
1231                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1232                        }
1233                } catch (SQLException sqlEx) {
1234                        checkAndFireConnectionError(sqlEx);
1235                }
1236        }
1237
1238        /*
1239         * (non-Javadoc)
1240         *
1241         * @see java.sql.CallableStatement#setTime(java.lang.String, java.sql.Time,
1242         *      java.util.Calendar)
1243         */
1244        public void setTime(String parameterName, Time x, Calendar cal)
1245                        throws SQLException {
1246                try {
1247                        if (this.wrappedStmt != null) {
1248                                ((CallableStatement) this.wrappedStmt).setTime(parameterName,
1249                                                x, cal);
1250                        } else {
1251                                throw SQLError.createSQLException(
1252                                                "No operations allowed after statement closed",
1253                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1254                        }
1255                } catch (SQLException sqlEx) {
1256                        checkAndFireConnectionError(sqlEx);
1257                }
1258        }
1259
1260        /*
1261         * (non-Javadoc)
1262         *
1263         * @see java.sql.CallableStatement#setTimestamp(java.lang.String,
1264         *      java.sql.Timestamp, java.util.Calendar)
1265         */
1266        public void setTimestamp(String parameterName, Timestamp x, Calendar cal)
1267                        throws SQLException {
1268                try {
1269                        if (this.wrappedStmt != null) {
1270                                ((CallableStatement) this.wrappedStmt).setTimestamp(
1271                                                parameterName, x, cal);
1272                        } else {
1273                                throw SQLError.createSQLException(
1274                                                "No operations allowed after statement closed",
1275                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1276                        }
1277                } catch (SQLException sqlEx) {
1278                        checkAndFireConnectionError(sqlEx);
1279                }
1280        }
1281
1282        /*
1283         * (non-Javadoc)
1284         *
1285         * @see java.sql.CallableStatement#setNull(java.lang.String, int,
1286         *      java.lang.String)
1287         */
1288        public void setNull(String parameterName, int sqlType, String typeName)
1289                        throws SQLException {
1290                try {
1291                        if (this.wrappedStmt != null) {
1292                                ((CallableStatement) this.wrappedStmt).setNull(parameterName,
1293                                                sqlType, typeName);
1294                        } else {
1295                                throw SQLError.createSQLException(
1296                                                "No operations allowed after statement closed",
1297                                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1298                        }
1299                } catch (SQLException sqlEx) {
1300                        checkAndFireConnectionError(sqlEx);
1301                }
1302        }
1303
1304        /*
1305         * (non-Javadoc)
1306         *
1307         * @see java.sql.CallableStatement#getString(int)
1308         */
1309        public String getString(String parameterName) throws SQLException {
1310                try {
1311                        if (this.wrappedStmt != null) {
1312                                return ((CallableStatement) this.wrappedStmt)
1313                                                .getString(parameterName);
1314                        }
1315                        throw SQLError.createSQLException(
1316                                "No operations allowed after statement closed",
1317                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1318
1319                } catch (SQLException sqlEx) {
1320                        checkAndFireConnectionError(sqlEx);
1321                }
1322                return null;
1323        }
1324
1325        /*
1326         * (non-Javadoc)
1327         *
1328         * @see java.sql.CallableStatement#getBoolean(int)
1329         */
1330        public boolean getBoolean(String parameterName) throws SQLException {
1331                try {
1332                        if (this.wrappedStmt != null) {
1333                                return ((CallableStatement) this.wrappedStmt)
1334                                                .getBoolean(parameterName);
1335                        }
1336                        throw SQLError.createSQLException(
1337                                "No operations allowed after statement closed",
1338                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1339
1340                } catch (SQLException sqlEx) {
1341                        checkAndFireConnectionError(sqlEx);
1342                }
1343
1344                return false;
1345        }
1346
1347        /*
1348         * (non-Javadoc)
1349         *
1350         * @see java.sql.CallableStatement#getByte(int)
1351         */
1352        public byte getByte(String parameterName) throws SQLException {
1353                try {
1354                        if (this.wrappedStmt != null) {
1355                                return ((CallableStatement) this.wrappedStmt)
1356                                                .getByte(parameterName);
1357                        }
1358                        throw SQLError.createSQLException(
1359                                "No operations allowed after statement closed",
1360                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1361
1362                } catch (SQLException sqlEx) {
1363                        checkAndFireConnectionError(sqlEx);
1364                }
1365
1366                return 0;
1367        }
1368
1369        /*
1370         * (non-Javadoc)
1371         *
1372         * @see java.sql.CallableStatement#getShort(int)
1373         */
1374        public short getShort(String parameterName) throws SQLException {
1375                try {
1376                        if (this.wrappedStmt != null) {
1377                                return ((CallableStatement) this.wrappedStmt)
1378                                                .getShort(parameterName);
1379                        }
1380                        throw SQLError.createSQLException(
1381                                "No operations allowed after statement closed",
1382                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1383
1384                } catch (SQLException sqlEx) {
1385                        checkAndFireConnectionError(sqlEx);
1386                }
1387
1388                return 0;
1389        }
1390
1391        /*
1392         * (non-Javadoc)
1393         *
1394         * @see java.sql.CallableStatement#getInt(int)
1395         */
1396        public int getInt(String parameterName) throws SQLException {
1397                try {
1398                        if (this.wrappedStmt != null) {
1399                                return ((CallableStatement) this.wrappedStmt)
1400                                                .getInt(parameterName);
1401                        }
1402                        throw SQLError.createSQLException(
1403                                "No operations allowed after statement closed",
1404                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1405
1406                } catch (SQLException sqlEx) {
1407                        checkAndFireConnectionError(sqlEx);
1408                }
1409
1410                return 0;
1411        }
1412
1413        /*
1414         * (non-Javadoc)
1415         *
1416         * @see java.sql.CallableStatement#getLong(int)
1417         */
1418        public long getLong(String parameterName) throws SQLException {
1419                try {
1420                        if (this.wrappedStmt != null) {
1421                                return ((CallableStatement) this.wrappedStmt)
1422                                                .getLong(parameterName);
1423                        }
1424                        throw SQLError.createSQLException(
1425                                "No operations allowed after statement closed",
1426                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1427
1428                } catch (SQLException sqlEx) {
1429                        checkAndFireConnectionError(sqlEx);
1430                }
1431
1432                return 0;
1433        }
1434
1435        /*
1436         * (non-Javadoc)
1437         *
1438         * @see java.sql.CallableStatement#getFloat(int)
1439         */
1440        public float getFloat(String parameterName) throws SQLException {
1441                try {
1442                        if (this.wrappedStmt != null) {
1443                                return ((CallableStatement) this.wrappedStmt)
1444                                                .getFloat(parameterName);
1445                        }
1446                        throw SQLError.createSQLException(
1447                                "No operations allowed after statement closed",
1448                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1449
1450                } catch (SQLException sqlEx) {
1451                        checkAndFireConnectionError(sqlEx);
1452                }
1453
1454                return 0;
1455        }
1456
1457        /*
1458         * (non-Javadoc)
1459         *
1460         * @see java.sql.CallableStatement#getDouble(int)
1461         */
1462        public double getDouble(String parameterName) throws SQLException {
1463                try {
1464                        if (this.wrappedStmt != null) {
1465                                return ((CallableStatement) this.wrappedStmt)
1466                                                .getDouble(parameterName);
1467                        }
1468                        throw SQLError.createSQLException(
1469                                "No operations allowed after statement closed",
1470                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1471
1472                } catch (SQLException sqlEx) {
1473                        checkAndFireConnectionError(sqlEx);
1474                }
1475
1476                return 0;
1477        }
1478
1479        /*
1480         * (non-Javadoc)
1481         *
1482         * @see java.sql.CallableStatement#getBytes(int)
1483         */
1484        public byte[] getBytes(String parameterName) throws SQLException {
1485                try {
1486                        if (this.wrappedStmt != null) {
1487                                return ((CallableStatement) this.wrappedStmt)
1488                                                .getBytes(parameterName);
1489                        }
1490                        throw SQLError.createSQLException(
1491                                "No operations allowed after statement closed",
1492                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1493
1494                } catch (SQLException sqlEx) {
1495                        checkAndFireConnectionError(sqlEx);
1496                }
1497
1498                return null;
1499        }
1500
1501        /*
1502         * (non-Javadoc)
1503         *
1504         * @see java.sql.CallableStatement#getDate(int)
1505         */
1506        public Date getDate(String parameterName) throws SQLException {
1507                try {
1508                        if (this.wrappedStmt != null) {
1509                                return ((CallableStatement) this.wrappedStmt)
1510                                                .getDate(parameterName);
1511                        }
1512                        throw SQLError.createSQLException(
1513                                "No operations allowed after statement closed",
1514                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1515
1516                } catch (SQLException sqlEx) {
1517                        checkAndFireConnectionError(sqlEx);
1518                }
1519
1520                return null;
1521        }
1522
1523        /*
1524         * (non-Javadoc)
1525         *
1526         * @see java.sql.CallableStatement#getTime(int)
1527         */
1528        public Time getTime(String parameterName) throws SQLException {
1529                try {
1530                        if (this.wrappedStmt != null) {
1531                                return ((CallableStatement) this.wrappedStmt)
1532                                                .getTime(parameterName);
1533                        }
1534                        throw SQLError.createSQLException(
1535                                "No operations allowed after statement closed",
1536                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1537
1538                } catch (SQLException sqlEx) {
1539                        checkAndFireConnectionError(sqlEx);
1540                }
1541
1542                return null;
1543        }
1544
1545        /*
1546         * (non-Javadoc)
1547         *
1548         * @see java.sql.CallableStatement#getTimestamp(int)
1549         */
1550        public Timestamp getTimestamp(String parameterName) throws SQLException {
1551                try {
1552                        if (this.wrappedStmt != null) {
1553                                return ((CallableStatement) this.wrappedStmt)
1554                                                .getTimestamp(parameterName);
1555                        }
1556                        throw SQLError.createSQLException(
1557                                "No operations allowed after statement closed",
1558                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1559
1560                } catch (SQLException sqlEx) {
1561                        checkAndFireConnectionError(sqlEx);
1562                }
1563
1564                return null;
1565        }
1566
1567        /*
1568         * (non-Javadoc)
1569         *
1570         * @see java.sql.CallableStatement#getObject(int)
1571         */
1572        public Object getObject(String parameterName) throws SQLException {
1573                try {
1574                        if (this.wrappedStmt != null) {
1575                                return ((CallableStatement) this.wrappedStmt)
1576                                                .getObject(parameterName);
1577                        }
1578                        throw SQLError.createSQLException(
1579                                "No operations allowed after statement closed",
1580                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1581
1582                } catch (SQLException sqlEx) {
1583                        checkAndFireConnectionError(sqlEx);
1584                }
1585
1586                return null;
1587        }
1588
1589        /*
1590         * (non-Javadoc)
1591         *
1592         * @see java.sql.CallableStatement#getBigDecimal(int)
1593         */
1594        public BigDecimal getBigDecimal(String parameterName) throws SQLException {
1595                try {
1596                        if (this.wrappedStmt != null) {
1597                                return ((CallableStatement) this.wrappedStmt)
1598                                                .getBigDecimal(parameterName);
1599                        }
1600                        throw SQLError.createSQLException(
1601                                "No operations allowed after statement closed",
1602                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1603
1604                } catch (SQLException sqlEx) {
1605                        checkAndFireConnectionError(sqlEx);
1606                }
1607
1608                return null;
1609        }
1610
1611        /*
1612         * (non-Javadoc)
1613         *
1614         * @see java.sql.CallableStatement#getObject(int, java.util.Map)
1615         */
1616        public Object getObject(String parameterName, Map<String, Class<?>> typeMap)
1617                        throws SQLException {
1618                try {
1619                        if (this.wrappedStmt != null) {
1620                                return ((CallableStatement) this.wrappedStmt).getObject(
1621                                                parameterName, typeMap);
1622                        }
1623                        throw SQLError.createSQLException(
1624                                "No operations allowed after statement closed",
1625                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1626
1627                } catch (SQLException sqlEx) {
1628                        checkAndFireConnectionError(sqlEx);
1629                }
1630                return null;
1631        }
1632
1633        /*
1634         * (non-Javadoc)
1635         *
1636         * @see java.sql.CallableStatement#getRef(int)
1637         */
1638        public Ref getRef(String parameterName) throws SQLException {
1639                try {
1640                        if (this.wrappedStmt != null) {
1641                                return ((CallableStatement) this.wrappedStmt)
1642                                                .getRef(parameterName);
1643                        }
1644                        throw SQLError.createSQLException(
1645                                "No operations allowed after statement closed",
1646                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1647
1648                } catch (SQLException sqlEx) {
1649                        checkAndFireConnectionError(sqlEx);
1650                }
1651
1652                return null;
1653        }
1654
1655        /*
1656         * (non-Javadoc)
1657         *
1658         * @see java.sql.CallableStatement#getBlob(int)
1659         */
1660        public Blob getBlob(String parameterName) throws SQLException {
1661                try {
1662                        if (this.wrappedStmt != null) {
1663                                return ((CallableStatement) this.wrappedStmt)
1664                                                .getBlob(parameterName);
1665                        }
1666                        throw SQLError.createSQLException(
1667                                "No operations allowed after statement closed",
1668                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1669
1670                } catch (SQLException sqlEx) {
1671                        checkAndFireConnectionError(sqlEx);
1672                }
1673
1674                return null;
1675        }
1676
1677        /*
1678         * (non-Javadoc)
1679         *
1680         * @see java.sql.CallableStatement#getClob(int)
1681         */
1682        public Clob getClob(String parameterName) throws SQLException {
1683                try {
1684                        if (this.wrappedStmt != null) {
1685                                return ((CallableStatement) this.wrappedStmt)
1686                                                .getClob(parameterName);
1687                        }
1688                        throw SQLError.createSQLException(
1689                                "No operations allowed after statement closed",
1690                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1691
1692                } catch (SQLException sqlEx) {
1693                        checkAndFireConnectionError(sqlEx);
1694                }
1695                return null;
1696        }
1697
1698        /*
1699         * (non-Javadoc)
1700         *
1701         * @see java.sql.CallableStatement#getArray(int)
1702         */
1703        public Array getArray(String parameterName) throws SQLException {
1704                try {
1705                        if (this.wrappedStmt != null) {
1706                                return ((CallableStatement) this.wrappedStmt)
1707                                                .getArray(parameterName);
1708                        }
1709                        throw SQLError.createSQLException(
1710                                "No operations allowed after statement closed",
1711                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1712
1713                } catch (SQLException sqlEx) {
1714                        checkAndFireConnectionError(sqlEx);
1715                }
1716                return null;
1717        }
1718
1719        /*
1720         * (non-Javadoc)
1721         *
1722         * @see java.sql.CallableStatement#getDate(int, java.util.Calendar)
1723         */
1724        public Date getDate(String parameterName, Calendar cal) throws SQLException {
1725                try {
1726                        if (this.wrappedStmt != null) {
1727                                return ((CallableStatement) this.wrappedStmt).getDate(
1728                                                parameterName, cal);
1729                        }
1730                        throw SQLError.createSQLException(
1731                                "No operations allowed after statement closed",
1732                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1733
1734                } catch (SQLException sqlEx) {
1735                        checkAndFireConnectionError(sqlEx);
1736                }
1737                return null;
1738        }
1739
1740        /*
1741         * (non-Javadoc)
1742         *
1743         * @see java.sql.CallableStatement#getTime(int, java.util.Calendar)
1744         */
1745        public Time getTime(String parameterName, Calendar cal) throws SQLException {
1746                try {
1747                        if (this.wrappedStmt != null) {
1748                                return ((CallableStatement) this.wrappedStmt).getTime(
1749                                                parameterName, cal);
1750                        }
1751                        throw SQLError.createSQLException(
1752                                "No operations allowed after statement closed",
1753                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1754
1755                } catch (SQLException sqlEx) {
1756                        checkAndFireConnectionError(sqlEx);
1757                }
1758                return null;
1759        }
1760
1761        /*
1762         * (non-Javadoc)
1763         *
1764         * @see java.sql.CallableStatement#getTimestamp(int, java.util.Calendar)
1765         */
1766        public Timestamp getTimestamp(String parameterName, Calendar cal)
1767                        throws SQLException {
1768                try {
1769                        if (this.wrappedStmt != null) {
1770                                return ((CallableStatement) this.wrappedStmt).getTimestamp(
1771                                                parameterName, cal);
1772                        }
1773                        throw SQLError.createSQLException(
1774                                "No operations allowed after statement closed",
1775                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1776
1777                } catch (SQLException sqlEx) {
1778                        checkAndFireConnectionError(sqlEx);
1779                }
1780                return null;
1781        }
1782
1783        /*
1784         * (non-Javadoc)
1785         *
1786         * @see java.sql.CallableStatement#getURL(java.lang.String)
1787         */
1788        public URL getURL(String parameterName) throws SQLException {
1789                try {
1790                        if (this.wrappedStmt != null) {
1791                                return ((CallableStatement) this.wrappedStmt)
1792                                                .getURL(parameterName);
1793                        }
1794                        throw SQLError.createSQLException(
1795                                "No operations allowed after statement closed",
1796                                SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1797
1798                } catch (SQLException sqlEx) {
1799                        checkAndFireConnectionError(sqlEx);
1800                }
1801
1802                return null;
1803        }
1804//
1805//      public Reader getCharacterStream(int parameterIndex) throws SQLException {
1806//              try {
1807//                      if (this.wrappedStmt != null) {
1808//                              return ((CallableStatement) this.wrappedStmt)
1809//                                              .getCharacterStream(parameterIndex);
1810//                      } else {
1811//                              throw SQLError.createSQLException(
1812//                                              "No operations allowed after statement closed",
1813//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1814//                      }
1815//              } catch (SQLException sqlEx) {
1816//                      checkAndFireConnectionError(sqlEx);
1817//              }
1818//             
1819//              return null;
1820//      }
1821//
1822//      public Reader getCharacterStream(String parameterName) throws SQLException {
1823//              try {
1824//                      if (this.wrappedStmt != null) {
1825//                              return ((CallableStatement) this.wrappedStmt)
1826//                                              .getCharacterStream(parameterName);
1827//                      } else {
1828//                              throw SQLError.createSQLException(
1829//                                              "No operations allowed after statement closed",
1830//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1831//                      }
1832//              } catch (SQLException sqlEx) {
1833//                      checkAndFireConnectionError(sqlEx);
1834//              }
1835//             
1836//              return null;
1837//      }
1838//
1839//      public Reader getNCharacterStream(int parameterIndex) throws SQLException {
1840//              try {
1841//                      if (this.wrappedStmt != null) {
1842//                              return ((CallableStatement) this.wrappedStmt)
1843//                                              .getCharacterStream(parameterIndex);
1844//                      } else {
1845//                              throw SQLError.createSQLException(
1846//                                              "No operations allowed after statement closed",
1847//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1848//                      }
1849//              } catch (SQLException sqlEx) {
1850//                      checkAndFireConnectionError(sqlEx);
1851//              }
1852//             
1853//              return null;
1854//      }
1855//
1856//      public Reader getNCharacterStream(String parameterName) throws SQLException {
1857//              try {
1858//                      if (this.wrappedStmt != null) {
1859//                              return ((CallableStatement) this.wrappedStmt)
1860//                                              .getNCharacterStream(parameterName);
1861//                      } else {
1862//                              throw SQLError.createSQLException(
1863//                                              "No operations allowed after statement closed",
1864//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1865//                      }
1866//              } catch (SQLException sqlEx) {
1867//                      checkAndFireConnectionError(sqlEx);
1868//              }
1869//             
1870//              return null;
1871//      }
1872//
1873//      public NClob getNClob(int parameterIndex) throws SQLException {
1874//              try {
1875//                      if (this.wrappedStmt != null) {
1876//                              return ((CallableStatement) this.wrappedStmt)
1877//                                              .getNClob(parameterIndex);
1878//                      } else {
1879//                              throw SQLError.createSQLException(
1880//                                              "No operations allowed after statement closed",
1881//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1882//                      }
1883//              } catch (SQLException sqlEx) {
1884//                      checkAndFireConnectionError(sqlEx);
1885//              }
1886//             
1887//              return null;
1888//      }
1889//
1890//      public NClob getNClob(String parameterName) throws SQLException {
1891//              try {
1892//                      if (this.wrappedStmt != null) {
1893//                              return ((CallableStatement) this.wrappedStmt)
1894//                                              .getNClob(parameterName);
1895//                      } else {
1896//                              throw SQLError.createSQLException(
1897//                                              "No operations allowed after statement closed",
1898//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1899//                      }
1900//              } catch (SQLException sqlEx) {
1901//                      checkAndFireConnectionError(sqlEx);
1902//              }
1903//             
1904//              return null;
1905//      }
1906//
1907//      public String getNString(int parameterIndex) throws SQLException {
1908//              try {
1909//                      if (this.wrappedStmt != null) {
1910//                              return ((CallableStatement) this.wrappedStmt)
1911//                                              .getNString(parameterIndex);
1912//                      } else {
1913//                              throw SQLError.createSQLException(
1914//                                              "No operations allowed after statement closed",
1915//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1916//                      }
1917//              } catch (SQLException sqlEx) {
1918//                      checkAndFireConnectionError(sqlEx);
1919//              }
1920//             
1921//              return null;
1922//      }
1923//
1924//      public String getNString(String parameterName) throws SQLException {
1925//              try {
1926//                      if (this.wrappedStmt != null) {
1927//                              return ((CallableStatement) this.wrappedStmt)
1928//                                              .getNString(parameterName);
1929//                      } else {
1930//                              throw SQLError.createSQLException(
1931//                                              "No operations allowed after statement closed",
1932//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1933//                      }
1934//              } catch (SQLException sqlEx) {
1935//                      checkAndFireConnectionError(sqlEx);
1936//              }
1937//             
1938//              return null;
1939//      }
1940//
1941//      public RowId getRowId(int parameterIndex) throws SQLException {
1942//              try {
1943//                      if (this.wrappedStmt != null) {
1944//                              return ((CallableStatement) this.wrappedStmt)
1945//                                              .getRowId(parameterIndex);
1946//                      } else {
1947//                              throw SQLError.createSQLException(
1948//                                              "No operations allowed after statement closed",
1949//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1950//                      }
1951//              } catch (SQLException sqlEx) {
1952//                      checkAndFireConnectionError(sqlEx);
1953//              }
1954//             
1955//              return null;
1956//      }
1957//
1958//      public RowId getRowId(String parameterName) throws SQLException {
1959//              try {
1960//                      if (this.wrappedStmt != null) {
1961//                              return ((CallableStatement) this.wrappedStmt)
1962//                                              .getRowId(parameterName);
1963//                      } else {
1964//                              throw SQLError.createSQLException(
1965//                                              "No operations allowed after statement closed",
1966//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1967//                      }
1968//              } catch (SQLException sqlEx) {
1969//                      checkAndFireConnectionError(sqlEx);
1970//              }
1971//             
1972//              return null;
1973//      }
1974//
1975//      public SQLXML getSQLXML(int parameterIndex) throws SQLException {
1976//              try {
1977//                      if (this.wrappedStmt != null) {
1978//                              return ((CallableStatement) this.wrappedStmt)
1979//                                              .getSQLXML(parameterIndex);
1980//                      } else {
1981//                              throw SQLError.createSQLException(
1982//                                              "No operations allowed after statement closed",
1983//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
1984//                      }
1985//              } catch (SQLException sqlEx) {
1986//                      checkAndFireConnectionError(sqlEx);
1987//              }
1988//             
1989//              return null;
1990//      }
1991//
1992//      public SQLXML getSQLXML(String parameterName) throws SQLException {
1993//              try {
1994//                      if (this.wrappedStmt != null) {
1995//                              return ((CallableStatement) this.wrappedStmt)
1996//                                              .getSQLXML(parameterName);
1997//                      } else {
1998//                              throw SQLError.createSQLException(
1999//                                              "No operations allowed after statement closed",
2000//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2001//                      }
2002//              } catch (SQLException sqlEx) {
2003//                      checkAndFireConnectionError(sqlEx);
2004//              }
2005//             
2006//              return null;
2007//      }
2008//
2009//      public void setAsciiStream(String parameterName, InputStream x) throws SQLException {
2010//              try {
2011//                      if (this.wrappedStmt != null) {
2012//                              ((CallableStatement) this.wrappedStmt)
2013//                                              .setAsciiStream(parameterName, x) ;
2014//                      } else {
2015//                              throw SQLError.createSQLException(
2016//                                              "No operations allowed after statement closed",
2017//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2018//                      }
2019//              } catch (SQLException sqlEx) {
2020//                      checkAndFireConnectionError(sqlEx);
2021//              }
2022//      }
2023//
2024//      public void setAsciiStream(String parameterName, InputStream x, long length) throws SQLException {
2025//              try {
2026//                      if (this.wrappedStmt != null) {
2027//                              ((CallableStatement) this.wrappedStmt)
2028//                                              .setAsciiStream(parameterName, x, length);
2029//                      } else {
2030//                              throw SQLError.createSQLException(
2031//                                              "No operations allowed after statement closed",
2032//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2033//                      }
2034//              } catch (SQLException sqlEx) {
2035//                      checkAndFireConnectionError(sqlEx);
2036//              }
2037//      }
2038//
2039//      public void setBinaryStream(String parameterName, InputStream x) throws SQLException {
2040//              try {
2041//                      if (this.wrappedStmt != null) {
2042//                              ((CallableStatement) this.wrappedStmt)
2043//                                              .setBinaryStream(parameterName, x);
2044//                      } else {
2045//                              throw SQLError.createSQLException(
2046//                                              "No operations allowed after statement closed",
2047//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2048//                      }
2049//              } catch (SQLException sqlEx) {
2050//                      checkAndFireConnectionError(sqlEx);
2051//              }
2052//      }
2053//
2054//      public void setBinaryStream(String parameterName, InputStream x, long length) throws SQLException {
2055//              try {
2056//                      if (this.wrappedStmt != null) {
2057//                              ((CallableStatement) this.wrappedStmt)
2058//                                              .setBinaryStream(parameterName, x, length);
2059//                      } else {
2060//                              throw SQLError.createSQLException(
2061//                                              "No operations allowed after statement closed",
2062//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2063//                      }
2064//              } catch (SQLException sqlEx) {
2065//                      checkAndFireConnectionError(sqlEx);
2066//              }
2067//      }
2068//
2069//      public void setBlob(String parameterName, Blob x) throws SQLException {
2070//              try {
2071//                      if (this.wrappedStmt != null) {
2072//                              ((CallableStatement) this.wrappedStmt)
2073//                                              .setBlob(parameterName, x);
2074//                      } else {
2075//                              throw SQLError.createSQLException(
2076//                                              "No operations allowed after statement closed",
2077//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2078//                      }
2079//              } catch (SQLException sqlEx) {
2080//                      checkAndFireConnectionError(sqlEx);
2081//              }
2082//      }
2083//
2084//      public void setBlob(String parameterName, InputStream inputStream) throws SQLException {
2085//              try {
2086//                      if (this.wrappedStmt != null) {
2087//                              ((CallableStatement) this.wrappedStmt)
2088//                                              .setBlob(parameterName, inputStream);
2089//                      } else {
2090//                              throw SQLError.createSQLException(
2091//                                              "No operations allowed after statement closed",
2092//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2093//                      }
2094//              } catch (SQLException sqlEx) {
2095//                      checkAndFireConnectionError(sqlEx);
2096//              }
2097//      }
2098//
2099//      public void setBlob(String parameterName, InputStream inputStream, long length) throws SQLException {
2100//              try {
2101//                      if (this.wrappedStmt != null) {
2102//                              ((CallableStatement) this.wrappedStmt)
2103//                                              .setBlob(parameterName, inputStream, length);
2104//                      } else {
2105//                              throw SQLError.createSQLException(
2106//                                              "No operations allowed after statement closed",
2107//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2108//                      }
2109//              } catch (SQLException sqlEx) {
2110//                      checkAndFireConnectionError(sqlEx);
2111//              }
2112//      }
2113//
2114//      public void setCharacterStream(String parameterName, Reader reader) throws SQLException {
2115//              try {
2116//                      if (this.wrappedStmt != null) {
2117//                              ((CallableStatement) this.wrappedStmt)
2118//                                              .setCharacterStream(parameterName, reader);
2119//                      } else {
2120//                              throw SQLError.createSQLException(
2121//                                              "No operations allowed after statement closed",
2122//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2123//                      }
2124//              } catch (SQLException sqlEx) {
2125//                      checkAndFireConnectionError(sqlEx);
2126//              }
2127//      }
2128//
2129//      public void setCharacterStream(String parameterName, Reader reader, long length) throws SQLException {
2130//              try {
2131//                      if (this.wrappedStmt != null) {
2132//                              ((CallableStatement) this.wrappedStmt)
2133//                                              .setCharacterStream(parameterName, reader, length);
2134//                      } else {
2135//                              throw SQLError.createSQLException(
2136//                                              "No operations allowed after statement closed",
2137//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2138//                      }
2139//              } catch (SQLException sqlEx) {
2140//                      checkAndFireConnectionError(sqlEx);
2141//              }
2142//      }
2143//
2144//      public void setClob(String parameterName, Clob x) throws SQLException {
2145//              try {
2146//                      if (this.wrappedStmt != null) {
2147//                              ((CallableStatement) this.wrappedStmt)
2148//                                              .setClob(parameterName, x);
2149//                      } else {
2150//                              throw SQLError.createSQLException(
2151//                                              "No operations allowed after statement closed",
2152//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2153//                      }
2154//              } catch (SQLException sqlEx) {
2155//                      checkAndFireConnectionError(sqlEx);
2156//              }
2157//      }
2158//
2159//      public void setClob(String parameterName, Reader reader) throws SQLException {
2160//              try {
2161//                      if (this.wrappedStmt != null) {
2162//                              ((CallableStatement) this.wrappedStmt)
2163//                                              .setClob(parameterName, reader);
2164//                      } else {
2165//                              throw SQLError.createSQLException(
2166//                                              "No operations allowed after statement closed",
2167//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2168//                      }
2169//              } catch (SQLException sqlEx) {
2170//                      checkAndFireConnectionError(sqlEx);
2171//              }
2172//      }
2173//
2174//      public void setClob(String parameterName, Reader reader, long length) throws SQLException {
2175//              try {
2176//                      if (this.wrappedStmt != null) {
2177//                              ((CallableStatement) this.wrappedStmt)
2178//                                              .setClob(parameterName, reader, length);
2179//                      } else {
2180//                              throw SQLError.createSQLException(
2181//                                              "No operations allowed after statement closed",
2182//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2183//                      }
2184//              } catch (SQLException sqlEx) {
2185//                      checkAndFireConnectionError(sqlEx);
2186//              }
2187//      }
2188//
2189//      public void setNCharacterStream(String parameterName, Reader value) throws SQLException {
2190//              try {
2191//                      if (this.wrappedStmt != null) {
2192//                              ((CallableStatement) this.wrappedStmt)
2193//                                              .setNCharacterStream(parameterName, value);
2194//                      } else {
2195//                              throw SQLError.createSQLException(
2196//                                              "No operations allowed after statement closed",
2197//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2198//                      }
2199//              } catch (SQLException sqlEx) {
2200//                      checkAndFireConnectionError(sqlEx);
2201//              }
2202//      }
2203//
2204//      public void setNCharacterStream(String parameterName, Reader value, long length) throws SQLException {
2205//              try {
2206//                      if (this.wrappedStmt != null) {
2207//                              ((CallableStatement) this.wrappedStmt)
2208//                                              .setNCharacterStream(parameterName, value, length);
2209//                      } else {
2210//                              throw SQLError.createSQLException(
2211//                                              "No operations allowed after statement closed",
2212//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2213//                      }
2214//              } catch (SQLException sqlEx) {
2215//                      checkAndFireConnectionError(sqlEx);
2216//              }
2217//      }
2218//
2219//      public void setNClob(String parameterName, NClob value) throws SQLException {
2220//              try {
2221//                      if (this.wrappedStmt != null) {
2222//                              ((CallableStatement) this.wrappedStmt)
2223//                                              .setNClob(parameterName, value);
2224//                      } else {
2225//                              throw SQLError.createSQLException(
2226//                                              "No operations allowed after statement closed",
2227//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2228//                      }
2229//              } catch (SQLException sqlEx) {
2230//                      checkAndFireConnectionError(sqlEx);
2231//              }
2232//      }
2233//
2234//      public void setNClob(String parameterName, Reader reader) throws SQLException {
2235//              try {
2236//                      if (this.wrappedStmt != null) {
2237//                              ((CallableStatement) this.wrappedStmt)
2238//                                              .setNClob(parameterName, reader);
2239//                      } else {
2240//                              throw SQLError.createSQLException(
2241//                                              "No operations allowed after statement closed",
2242//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2243//                      }
2244//              } catch (SQLException sqlEx) {
2245//                      checkAndFireConnectionError(sqlEx);
2246//              }
2247//      }
2248//
2249//      public void setNClob(String parameterName, Reader reader, long length) throws SQLException {
2250//              try {
2251//                      if (this.wrappedStmt != null) {
2252//                              ((CallableStatement) this.wrappedStmt)
2253//                                              .setNClob(parameterName, reader, length);
2254//                      } else {
2255//                              throw SQLError.createSQLException(
2256//                                              "No operations allowed after statement closed",
2257//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2258//                      }
2259//              } catch (SQLException sqlEx) {
2260//                      checkAndFireConnectionError(sqlEx);
2261//              }
2262//      }
2263//
2264//      public void setNString(String parameterName, String value) throws SQLException {
2265//              try {
2266//                      if (this.wrappedStmt != null) {
2267//                              ((CallableStatement) this.wrappedStmt)
2268//                                              .setNString(parameterName, value);
2269//                      } else {
2270//                              throw SQLError.createSQLException(
2271//                                              "No operations allowed after statement closed",
2272//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2273//                      }
2274//              } catch (SQLException sqlEx) {
2275//                      checkAndFireConnectionError(sqlEx);
2276//              }
2277//      }
2278//
2279//      public void setRowId(String parameterName, RowId x) throws SQLException {
2280//              try {
2281//                      if (this.wrappedStmt != null) {
2282//                              ((CallableStatement) this.wrappedStmt)
2283//                                              .setRowId(parameterName, x);
2284//                      } else {
2285//                              throw SQLError.createSQLException(
2286//                                              "No operations allowed after statement closed",
2287//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2288//                      }
2289//              } catch (SQLException sqlEx) {
2290//                      checkAndFireConnectionError(sqlEx);
2291//              }
2292//      }
2293//
2294//      public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException {
2295//              try {
2296//                      if (this.wrappedStmt != null) {
2297//                              ((CallableStatement) this.wrappedStmt)
2298//                                              .setSQLXML(parameterName, xmlObject);
2299//                      } else {
2300//                              throw SQLError.createSQLException(
2301//                                              "No operations allowed after statement closed",
2302//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2303//                      }
2304//              } catch (SQLException sqlEx) {
2305//                      checkAndFireConnectionError(sqlEx);
2306//              }
2307//      }
2308//
2309//      public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException {
2310//              try {
2311//                      if (this.wrappedStmt != null) {
2312//                              ((CallableStatement) this.wrappedStmt)
2313//                                              .setAsciiStream(parameterIndex, x);
2314//                      } else {
2315//                              throw SQLError.createSQLException(
2316//                                              "No operations allowed after statement closed",
2317//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2318//                      }
2319//              } catch (SQLException sqlEx) {
2320//                      checkAndFireConnectionError(sqlEx);
2321//              }
2322//      }
2323//
2324//      public void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException {
2325//              try {
2326//                      if (this.wrappedStmt != null) {
2327//                              ((CallableStatement) this.wrappedStmt)
2328//                                              .setAsciiStream(parameterIndex, x, length);
2329//                      } else {
2330//                              throw SQLError.createSQLException(
2331//                                              "No operations allowed after statement closed",
2332//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2333//                      }
2334//              } catch (SQLException sqlEx) {
2335//                      checkAndFireConnectionError(sqlEx);
2336//              }
2337//      }
2338//
2339//      public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException {
2340//              try {
2341//                      if (this.wrappedStmt != null) {
2342//                              ((CallableStatement) this.wrappedStmt)
2343//                                              .setBinaryStream(parameterIndex, x) ;
2344//                      } else {
2345//                              throw SQLError.createSQLException(
2346//                                              "No operations allowed after statement closed",
2347//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2348//                      }
2349//              } catch (SQLException sqlEx) {
2350//                      checkAndFireConnectionError(sqlEx);
2351//              }
2352//      }
2353//
2354//      public void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException {
2355//              try {
2356//                      if (this.wrappedStmt != null) {
2357//                              ((CallableStatement) this.wrappedStmt)
2358//                                              .setBinaryStream(parameterIndex, x, length);
2359//                      } else {
2360//                              throw SQLError.createSQLException(
2361//                                              "No operations allowed after statement closed",
2362//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2363//                      }
2364//              } catch (SQLException sqlEx) {
2365//                      checkAndFireConnectionError(sqlEx);
2366//              }
2367//      }
2368//
2369//      public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
2370//              try {
2371//                      if (this.wrappedStmt != null) {
2372//                              ((CallableStatement) this.wrappedStmt)
2373//                                              .setBlob(parameterIndex, inputStream);
2374//                      } else {
2375//                              throw SQLError.createSQLException(
2376//                                              "No operations allowed after statement closed",
2377//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2378//                      }
2379//              } catch (SQLException sqlEx) {
2380//                      checkAndFireConnectionError(sqlEx);
2381//              }
2382//      }
2383//
2384//      public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
2385//              try {
2386//                      if (this.wrappedStmt != null) {
2387//                              ((CallableStatement) this.wrappedStmt)
2388//                                              .setBlob(parameterIndex, inputStream, length);
2389//                      } else {
2390//                              throw SQLError.createSQLException(
2391//                                              "No operations allowed after statement closed",
2392//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2393//                      }
2394//              } catch (SQLException sqlEx) {
2395//                      checkAndFireConnectionError(sqlEx);
2396//              }
2397//      }
2398//
2399//      public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
2400//              try {
2401//                      if (this.wrappedStmt != null) {
2402//                              ((CallableStatement) this.wrappedStmt)
2403//                                              .setCharacterStream(parameterIndex, reader);
2404//                      } else {
2405//                              throw SQLError.createSQLException(
2406//                                              "No operations allowed after statement closed",
2407//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2408//                      }
2409//              } catch (SQLException sqlEx) {
2410//                      checkAndFireConnectionError(sqlEx);
2411//              }
2412//      }
2413//
2414//      public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException {
2415//              try {
2416//                      if (this.wrappedStmt != null) {
2417//                              ((CallableStatement) this.wrappedStmt)
2418//                                              .getCharacterStream(parameterIndex);
2419//                      } else {
2420//                              throw SQLError.createSQLException(
2421//                                              "No operations allowed after statement closed",
2422//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2423//                      }
2424//              } catch (SQLException sqlEx) {
2425//                      checkAndFireConnectionError(sqlEx);
2426//              }
2427//      }
2428//
2429//      public void setClob(int parameterIndex, Reader reader) throws SQLException {
2430//              try {
2431//                      if (this.wrappedStmt != null) {
2432//                              ((CallableStatement) this.wrappedStmt)
2433//                                              .setClob(parameterIndex, reader);
2434//                      } else {
2435//                              throw SQLError.createSQLException(
2436//                                              "No operations allowed after statement closed",
2437//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2438//                      }
2439//              } catch (SQLException sqlEx) {
2440//                      checkAndFireConnectionError(sqlEx);
2441//              }
2442//      }
2443//
2444//      public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
2445//              try {
2446//                      if (this.wrappedStmt != null) {
2447//                              ((CallableStatement) this.wrappedStmt)
2448//                                              .setClob(parameterIndex, reader, length);
2449//                      } else {
2450//                              throw SQLError.createSQLException(
2451//                                              "No operations allowed after statement closed",
2452//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2453//                      }
2454//              } catch (SQLException sqlEx) {
2455//                      checkAndFireConnectionError(sqlEx);
2456//              }
2457//      }
2458//
2459//      public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException {
2460//              try {
2461//                      if (this.wrappedStmt != null) {
2462//                              ((CallableStatement) this.wrappedStmt)
2463//                                              .setNCharacterStream(parameterIndex, value);
2464//                      } else {
2465//                              throw SQLError.createSQLException(
2466//                                              "No operations allowed after statement closed",
2467//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2468//                      }
2469//              } catch (SQLException sqlEx) {
2470//                      checkAndFireConnectionError(sqlEx);
2471//              }
2472//     
2473//      }
2474//
2475//      public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
2476//              try {
2477//                      if (this.wrappedStmt != null) {
2478//                              ((CallableStatement) this.wrappedStmt)
2479//                                              .setNCharacterStream(parameterIndex, value, length);
2480//                      } else {
2481//                              throw SQLError.createSQLException(
2482//                                              "No operations allowed after statement closed",
2483//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2484//                      }
2485//              } catch (SQLException sqlEx) {
2486//                      checkAndFireConnectionError(sqlEx);
2487//              }
2488//      }
2489//
2490//      public void setNClob(int parameterIndex, NClob value) throws SQLException {
2491//              try {
2492//                      if (this.wrappedStmt != null) {
2493//                              ((CallableStatement) this.wrappedStmt)
2494//                                              .setNClob(parameterIndex, value);
2495//                      } else {
2496//                              throw SQLError.createSQLException(
2497//                                              "No operations allowed after statement closed",
2498//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2499//                      }
2500//              } catch (SQLException sqlEx) {
2501//                      checkAndFireConnectionError(sqlEx);
2502//              }
2503//      }
2504//
2505//      public void setNClob(int parameterIndex, Reader reader) throws SQLException {
2506//              try {
2507//                      if (this.wrappedStmt != null) {
2508//                              ((CallableStatement) this.wrappedStmt)
2509//                                              .setNClob(parameterIndex, reader);
2510//                      } else {
2511//                              throw SQLError.createSQLException(
2512//                                              "No operations allowed after statement closed",
2513//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2514//                      }
2515//              } catch (SQLException sqlEx) {
2516//                      checkAndFireConnectionError(sqlEx);
2517//              }
2518//      }
2519//
2520//      public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
2521//              try {
2522//                      if (this.wrappedStmt != null) {
2523//                              ((CallableStatement) this.wrappedStmt)
2524//                                              .setNClob(parameterIndex, reader, length);
2525//                      } else {
2526//                              throw SQLError.createSQLException(
2527//                                              "No operations allowed after statement closed",
2528//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2529//                      }
2530//              } catch (SQLException sqlEx) {
2531//                      checkAndFireConnectionError(sqlEx);
2532//              }
2533//      }
2534//
2535//      public void setNString(int parameterIndex, String value) throws SQLException {
2536//              try {
2537//                      if (this.wrappedStmt != null) {
2538//                              ((CallableStatement) this.wrappedStmt)
2539//                                              .setNString(parameterIndex, value);
2540//                      } else {
2541//                              throw SQLError.createSQLException(
2542//                                              "No operations allowed after statement closed",
2543//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2544//                      }
2545//              } catch (SQLException sqlEx) {
2546//                      checkAndFireConnectionError(sqlEx);
2547//              }
2548//      }
2549//
2550//      public void setRowId(int parameterIndex, RowId x) throws SQLException {
2551//              try {
2552//                      if (this.wrappedStmt != null) {
2553//                              ((CallableStatement) this.wrappedStmt)
2554//                                              .setRowId(parameterIndex, x);
2555//                      } else {
2556//                              throw SQLError.createSQLException(
2557//                                              "No operations allowed after statement closed",
2558//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2559//                      }
2560//              } catch (SQLException sqlEx) {
2561//                      checkAndFireConnectionError(sqlEx);
2562//              }
2563//      }
2564//
2565//      public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
2566//              try {
2567//                      if (this.wrappedStmt != null) {
2568//                              ((CallableStatement) this.wrappedStmt)
2569//                                              .setSQLXML(parameterIndex, xmlObject);
2570//                      } else {
2571//                              throw SQLError.createSQLException(
2572//                                              "No operations allowed after statement closed",
2573//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2574//                      }
2575//              } catch (SQLException sqlEx) {
2576//                      checkAndFireConnectionError(sqlEx);
2577//              }
2578//             
2579//      }
2580//
2581//      public boolean isClosed() throws SQLException {
2582//              try {
2583//                      if (this.wrappedStmt != null) {
2584//                              return ((CallableStatement) this.wrappedStmt)
2585//                                              .isClosed();
2586//                      } else {
2587//                              throw SQLError.createSQLException(
2588//                                              "No operations allowed after statement closed",
2589//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2590//                      }
2591//              } catch (SQLException sqlEx) {
2592//                      checkAndFireConnectionError(sqlEx);
2593//              }
2594//             
2595//              return true;
2596//      }
2597//
2598//      public boolean isPoolable() throws SQLException {
2599//              try {
2600//                      if (this.wrappedStmt != null) {
2601//                              return ((CallableStatement) this.wrappedStmt)
2602//                                              . isPoolable();
2603//                      } else {
2604//                              throw SQLError.createSQLException(
2605//                                              "No operations allowed after statement closed",
2606//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2607//                      }
2608//              } catch (SQLException sqlEx) {
2609//                      checkAndFireConnectionError(sqlEx);
2610//              }
2611//             
2612//              return false;
2613//      }
2614//
2615//      public void setPoolable(boolean poolable) throws SQLException {
2616//              try {
2617//                      if (this.wrappedStmt != null) {
2618//                              ((CallableStatement) this.wrappedStmt)
2619//                                              .setPoolable(poolable);
2620//                      } else {
2621//                              throw SQLError.createSQLException(
2622//                                              "No operations allowed after statement closed",
2623//                                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
2624//                      }
2625//              } catch (SQLException sqlEx) {
2626//                      checkAndFireConnectionError(sqlEx);
2627//              }
2628//             
2629//      }
2630//
2631//      public boolean isWrapperFor(Class arg0) throws SQLException {
2632//              throw SQLError.notImplemented();
2633//      }
2634//
2635//      public Object unwrap(Class arg0) throws SQLException {
2636//              throw SQLError.notImplemented();
2637//      }
2638
2639}
Note: See TracBrowser for help on using the repository browser.