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 | |
---|
26 | package com.mysql.jdbc.jdbc2.optional; |
---|
27 | |
---|
28 | import java.io.InputStream; |
---|
29 | import java.io.Reader; |
---|
30 | import java.lang.reflect.Constructor; |
---|
31 | import java.math.BigDecimal; |
---|
32 | import java.net.URL; |
---|
33 | import java.sql.Array; |
---|
34 | import java.sql.Blob; |
---|
35 | import java.sql.CallableStatement; |
---|
36 | import java.sql.Clob; |
---|
37 | import java.sql.Date; |
---|
38 | import java.sql.Ref; |
---|
39 | import java.sql.SQLException; |
---|
40 | import java.sql.Time; |
---|
41 | import java.sql.Timestamp; |
---|
42 | import java.util.Calendar; |
---|
43 | import java.util.Map; |
---|
44 | |
---|
45 | import com.mysql.jdbc.SQLError; |
---|
46 | import 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 | */ |
---|
54 | public 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 | } |
---|