Develop and Download Open Source Software

JDBC Debugger

Browse Subversion Repository

/[jdbcdebugger]/jdbcdebugger/trunk/src/jp/co/powerbeans/jdbcdebug/sql/CallableStatement.java

Contents of /jdbcdebugger/trunk/src/jp/co/powerbeans/jdbcdebug/sql/CallableStatement.java

Parent Directory Parent Directory | Revision Log Revision Log

Revision 34 - (show annotations) (download) (as text)
Fri Feb 4 08:45:40 2011 UTC (13 years, 2 months ago) by amsoft
File MIME type: text/x-java
File size: 50312 byte(s) 
add ijyou
1 package jp.co.powerbeans.jdbcdebug.sql;
2
3 import java.io.InputStream;
4 import java.io.Reader;
5 import java.math.BigDecimal;
6 import java.net.URL;
7 import java.sql.Array;
8 import java.sql.Blob;
9 import java.sql.Clob;
10 import java.sql.Connection;
11 import java.sql.Date;
12 import java.sql.NClob;
13 import java.sql.ParameterMetaData;
14 import java.sql.Ref;
15 import java.sql.ResultSet;
16 import java.sql.ResultSetMetaData;
17 import java.sql.RowId;
18 import java.sql.SQLException;
19 import java.sql.SQLWarning;
20 import java.sql.SQLXML;
21 import java.sql.Time;
22 import java.sql.Timestamp;
23 import java.util.Calendar;
24 import java.util.Map;
25
26 import jp.co.powerbeans.jdbcdebug.util.Log;
27 import jp.co.powerbeans.jdbcdebug.util.Survey;
28
29
30 /**
31 * <p>タイトル: CallableStatement</p>
32 * <p>説明: </p>
33 * <p>Created on 2003/10/01</p>
34 * @author 門田明彦
35 * @version $Revision: 1.1 $
36 */
37 public class CallableStatement implements java.sql.CallableStatement {
38
39 /** 実 java.sql.CallableStatement */
40 java.sql.CallableStatement st;
41
42 /**
43 * コンストラクタ
44 * @param statement
45 */
46 protected CallableStatement(java.sql.CallableStatement statement) {
47
48 st = statement;
49 }
50
51 /**
52 * コンストラクタ
53 */
54 private CallableStatement() {
55 super();
56 }
57
58 /* (non-Javadoc)
59 * @see java.sql.CallableStatement#registerOutParameter(int, int)
60 */
61 public void registerOutParameter(int parameterIndex, int sqlType)
62 throws SQLException {
63
64 st.registerOutParameter(parameterIndex, sqlType);
65 }
66
67 /* (non-Javadoc)
68 * @see java.sql.CallableStatement#registerOutParameter(int, int, int)
69 */
70 public void registerOutParameter(
71 int parameterIndex,
72 int sqlType,
73 int scale)
74 throws SQLException {
75
76 st.registerOutParameter(parameterIndex, sqlType, scale);
77 }
78
79 /* (non-Javadoc)
80 * @see java.sql.CallableStatement#wasNull()
81 */
82 public boolean wasNull() throws SQLException {
83
84 return st.wasNull();
85 }
86
87 /* (non-Javadoc)
88 * @see java.sql.CallableStatement#getString(int)
89 */
90 public String getString(int parameterIndex) throws SQLException {
91
92 return st.getString(parameterIndex);
93 }
94
95 /* (non-Javadoc)
96 * @see java.sql.CallableStatement#getBoolean(int)
97 */
98 public boolean getBoolean(int parameterIndex) throws SQLException {
99
100 return st.getBoolean(parameterIndex);
101 }
102
103 /* (non-Javadoc)
104 * @see java.sql.CallableStatement#getByte(int)
105 */
106 public byte getByte(int parameterIndex) throws SQLException {
107
108 return st.getByte(parameterIndex);
109 }
110
111 /* (non-Javadoc)
112 * @see java.sql.CallableStatement#getShort(int)
113 */
114 public short getShort(int parameterIndex) throws SQLException {
115
116 return st.getShort(parameterIndex);
117 }
118
119 /* (non-Javadoc)
120 * @see java.sql.CallableStatement#getInt(int)
121 */
122 public int getInt(int parameterIndex) throws SQLException {
123
124 return st.getInt(parameterIndex);
125 }
126
127 /* (non-Javadoc)
128 * @see java.sql.CallableStatement#getLong(int)
129 */
130 public long getLong(int parameterIndex) throws SQLException {
131
132 return st.getLong(parameterIndex);
133 }
134
135 /* (non-Javadoc)
136 * @see java.sql.CallableStatement#getFloat(int)
137 */
138 public float getFloat(int parameterIndex) throws SQLException {
139
140 return st.getFloat(parameterIndex);
141 }
142
143 /* (non-Javadoc)
144 * @see java.sql.CallableStatement#getDouble(int)
145 */
146 public double getDouble(int parameterIndex) throws SQLException {
147
148 return st.getDouble(parameterIndex);
149 }
150
151 /**
152 * @see java.sql.CallableStatement#getBigDecimal(int, int)
153 * @deprecated
154 */
155 public BigDecimal getBigDecimal(int parameterIndex, int scale)
156 throws SQLException {
157
158 return st.getBigDecimal(parameterIndex, scale);
159 }
160
161 /* (non-Javadoc)
162 * @see java.sql.CallableStatement#getBytes(int)
163 */
164 public byte[] getBytes(int parameterIndex) throws SQLException {
165
166 return st.getBytes(parameterIndex);
167 }
168
169 /* (non-Javadoc)
170 * @see java.sql.CallableStatement#getDate(int)
171 */
172 public Date getDate(int parameterIndex) throws SQLException {
173
174 return st.getDate(parameterIndex);
175 }
176
177 /* (non-Javadoc)
178 * @see java.sql.CallableStatement#getTime(int)
179 */
180 public Time getTime(int parameterIndex) throws SQLException {
181
182 return st.getTime(parameterIndex);
183 }
184
185 /* (non-Javadoc)
186 * @see java.sql.CallableStatement#getTimestamp(int)
187 */
188 public Timestamp getTimestamp(int parameterIndex) throws SQLException {
189
190 return st.getTimestamp(parameterIndex);
191 }
192
193 /* (non-Javadoc)
194 * @see java.sql.CallableStatement#getObject(int)
195 */
196 public Object getObject(int parameterIndex) throws SQLException {
197
198 return st.getObject(parameterIndex);
199 }
200
201 /* (non-Javadoc)
202 * @see java.sql.CallableStatement#getBigDecimal(int)
203 */
204 public BigDecimal getBigDecimal(int parameterIndex) throws SQLException {
205
206 return st.getBigDecimal(parameterIndex);
207 }
208
209 /* (non-Javadoc)
210 * @see java.sql.CallableStatement#getObject(int, java.util.Map)
211 */
212 public Object getObject(int i, Map map) throws SQLException {
213
214 return st.getObject(i, map);
215 }
216
217 /* (non-Javadoc)
218 * @see java.sql.CallableStatement#getRef(int)
219 */
220 public Ref getRef(int i) throws SQLException {
221
222 return st.getRef(i);
223 }
224
225 /* (non-Javadoc)
226 * @see java.sql.CallableStatement#getBlob(int)
227 */
228 public Blob getBlob(int i) throws SQLException {
229
230 return st.getBlob(i);
231 }
232
233 /* (non-Javadoc)
234 * @see java.sql.CallableStatement#getClob(int)
235 */
236 public Clob getClob(int i) throws SQLException {
237
238 return st.getClob(i);
239 }
240
241 /* (non-Javadoc)
242 * @see java.sql.CallableStatement#getArray(int)
243 */
244 public Array getArray(int i) throws SQLException {
245
246 return st.getArray(i);
247 }
248
249 /* (non-Javadoc)
250 * @see java.sql.CallableStatement#getDate(int, java.util.Calendar)
251 */
252 public Date getDate(int parameterIndex, Calendar cal) throws SQLException {
253
254 return st.getDate(parameterIndex, cal);
255 }
256
257 /* (non-Javadoc)
258 * @see java.sql.CallableStatement#getTime(int, java.util.Calendar)
259 */
260 public Time getTime(int parameterIndex, Calendar cal) throws SQLException {
261
262 return st.getTime(parameterIndex, cal);
263 }
264
265 /* (non-Javadoc)
266 * @see java.sql.CallableStatement#getTimestamp(int, java.util.Calendar)
267 */
268 public Timestamp getTimestamp(int parameterIndex, Calendar cal)
269 throws SQLException {
270
271 return st.getTimestamp(parameterIndex, cal);
272 }
273
274 /* (non-Javadoc)
275 * @see java.sql.CallableStatement#registerOutParameter(int, int, java.lang.String)
276 */
277 public void registerOutParameter(
278 int paramIndex,
279 int sqlType,
280 String typeName)
281 throws SQLException {
282
283 st.registerOutParameter(paramIndex, sqlType, typeName);
284 }
285
286 /* (non-Javadoc)
287 * @see java.sql.CallableStatement#registerOutParameter(java.lang.String, int)
288 */
289 public void registerOutParameter(String parameterName, int sqlType)
290 throws SQLException {
291
292 st.registerOutParameter(parameterName, sqlType);
293 }
294
295 /* (non-Javadoc)
296 * @see java.sql.CallableStatement#registerOutParameter(java.lang.String, int, int)
297 */
298 public void registerOutParameter(
299 String parameterName,
300 int sqlType,
301 int scale)
302 throws SQLException {
303
304 st.registerOutParameter(parameterName, sqlType, scale);
305 }
306
307 /* (non-Javadoc)
308 * @see java.sql.CallableStatement#registerOutParameter(java.lang.String, int, java.lang.String)
309 */
310 public void registerOutParameter(
311 String parameterName,
312 int sqlType,
313 String typeName)
314 throws SQLException {
315
316 st.registerOutParameter(parameterName, sqlType, typeName);
317 }
318
319 /* (non-Javadoc)
320 * @see java.sql.CallableStatement#getURL(int)
321 */
322 public URL getURL(int parameterIndex) throws SQLException {
323
324 return st.getURL(parameterIndex);
325 }
326
327 /* (non-Javadoc)
328 * @see java.sql.CallableStatement#setURL(java.lang.String, java.net.URL)
329 */
330 public void setURL(String parameterName, URL val) throws SQLException {
331
332 st.setURL(parameterName, val);
333 }
334
335 /* (non-Javadoc)
336 * @see java.sql.CallableStatement#setNull(java.lang.String, int)
337 */
338 public void setNull(String parameterName, int sqlType)
339 throws SQLException {
340
341 st.setNull(parameterName, sqlType);
342 }
343
344 /* (non-Javadoc)
345 * @see java.sql.CallableStatement#setBoolean(java.lang.String, boolean)
346 */
347 public void setBoolean(String parameterName, boolean x)
348 throws SQLException {
349
350 st.setBoolean(parameterName, x);
351 }
352
353 /* (non-Javadoc)
354 * @see java.sql.CallableStatement#setByte(java.lang.String, byte)
355 */
356 public void setByte(String parameterName, byte x) throws SQLException {
357
358 st.setByte(parameterName, x);
359 }
360
361 /* (non-Javadoc)
362 * @see java.sql.CallableStatement#setShort(java.lang.String, short)
363 */
364 public void setShort(String parameterName, short x) throws SQLException {
365
366 st.setShort(parameterName, x);
367 }
368
369 /* (non-Javadoc)
370 * @see java.sql.CallableStatement#setInt(java.lang.String, int)
371 */
372 public void setInt(String parameterName, int x) throws SQLException {
373
374 st.setInt(parameterName, x);
375 }
376
377 /* (non-Javadoc)
378 * @see java.sql.CallableStatement#setLong(java.lang.String, long)
379 */
380 public void setLong(String parameterName, long x) throws SQLException {
381
382 st.setLong(parameterName, x);
383 }
384
385 /* (non-Javadoc)
386 * @see java.sql.CallableStatement#setFloat(java.lang.String, float)
387 */
388 public void setFloat(String parameterName, float x) throws SQLException {
389
390 st.setFloat(parameterName, x);
391 }
392
393 /* (non-Javadoc)
394 * @see java.sql.CallableStatement#setDouble(java.lang.String, double)
395 */
396 public void setDouble(String parameterName, double x) throws SQLException {
397
398 st.setDouble(parameterName, x);
399 }
400
401 /* (non-Javadoc)
402 * @see java.sql.CallableStatement#setBigDecimal(java.lang.String, java.math.BigDecimal)
403 */
404 public void setBigDecimal(String parameterName, BigDecimal x)
405 throws SQLException {
406
407 st.setBigDecimal(parameterName, x);
408 }
409
410 /* (non-Javadoc)
411 * @see java.sql.CallableStatement#setString(java.lang.String, java.lang.String)
412 */
413 public void setString(String parameterName, String x) throws SQLException {
414
415 st.setString(parameterName, x);
416 }
417
418 /* (non-Javadoc)
419 * @see java.sql.CallableStatement#setBytes(java.lang.String, byte[])
420 */
421 public void setBytes(String parameterName, byte[] x) throws SQLException {
422
423 st.setBytes(parameterName, x);
424 }
425
426 /* (non-Javadoc)
427 * @see java.sql.CallableStatement#setDate(java.lang.String, java.sql.Date)
428 */
429 public void setDate(String parameterName, Date x) throws SQLException {
430
431 st.setDate(parameterName, x);
432 }
433
434 /* (non-Javadoc)
435 * @see java.sql.CallableStatement#setTime(java.lang.String, java.sql.Time)
436 */
437 public void setTime(String parameterName, Time x) throws SQLException {
438
439 st.setTime(parameterName, x);
440 }
441
442 /* (non-Javadoc)
443 * @see java.sql.CallableStatement#setTimestamp(java.lang.String, java.sql.Timestamp)
444 */
445 public void setTimestamp(String parameterName, Timestamp x)
446 throws SQLException {
447
448 st.setTimestamp(parameterName, x);
449 }
450
451 /* (non-Javadoc)
452 * @see java.sql.CallableStatement#setAsciiStream(java.lang.String, java.io.InputStream, int)
453 */
454 public void setAsciiStream(String parameterName, InputStream x, int length)
455 throws SQLException {
456
457 st.setAsciiStream(parameterName, x, length);
458 }
459
460 /* (non-Javadoc)
461 * @see java.sql.CallableStatement#setBinaryStream(java.lang.String, java.io.InputStream, int)
462 */
463 public void setBinaryStream(
464 String parameterName,
465 InputStream x,
466 int length)
467 throws SQLException {
468
469 st.setBinaryStream(parameterName, x, length);
470 }
471
472 /* (non-Javadoc)
473 * @see java.sql.CallableStatement#setObject(java.lang.String, java.lang.Object, int, int)
474 */
475 public void setObject(
476 String parameterName,
477 Object x,
478 int targetSqlType,
479 int scale)
480 throws SQLException {
481
482 st.setObject(parameterName, x, targetSqlType, scale);
483 }
484
485 /* (non-Javadoc)
486 * @see java.sql.CallableStatement#setObject(java.lang.String, java.lang.Object, int)
487 */
488 public void setObject(String parameterName, Object x, int targetSqlType)
489 throws SQLException {
490
491 st.setObject(parameterName, x, targetSqlType);
492 }
493
494 /* (non-Javadoc)
495 * @see java.sql.CallableStatement#setObject(java.lang.String, java.lang.Object)
496 */
497 public void setObject(String parameterName, Object x) throws SQLException {
498
499 st.setObject(parameterName, x);
500 }
501
502 /* (non-Javadoc)
503 * @see java.sql.CallableStatement#setCharacterStream(java.lang.String, java.io.Reader, int)
504 */
505 public void setCharacterStream(
506 String parameterName,
507 Reader reader,
508 int length)
509 throws SQLException {
510
511 st.setCharacterStream(parameterName, reader, length);
512 }
513
514 /* (non-Javadoc)
515 * @see java.sql.CallableStatement#setDate(java.lang.String, java.sql.Date, java.util.Calendar)
516 */
517 public void setDate(String parameterName, Date x, Calendar cal)
518 throws SQLException {
519
520 st.setDate(parameterName, x, cal);
521 }
522
523 /* (non-Javadoc)
524 * @see java.sql.CallableStatement#setTime(java.lang.String, java.sql.Time, java.util.Calendar)
525 */
526 public void setTime(String parameterName, Time x, Calendar cal)
527 throws SQLException {
528
529 st.setTime(parameterName, x, cal);
530 }
531
532 /* (non-Javadoc)
533 * @see java.sql.CallableStatement#setTimestamp(java.lang.String, java.sql.Timestamp, java.util.Calendar)
534 */
535 public void setTimestamp(String parameterName, Timestamp x, Calendar cal)
536 throws SQLException {
537
538 st.setTimestamp(parameterName, x, cal);
539 }
540
541 /* (non-Javadoc)
542 * @see java.sql.CallableStatement#setNull(java.lang.String, int, java.lang.String)
543 */
544 public void setNull(String parameterName, int sqlType, String typeName)
545 throws SQLException {
546
547 st.setNull(parameterName, sqlType, typeName);
548 }
549
550 /* (non-Javadoc)
551 * @see java.sql.CallableStatement#getString(java.lang.String)
552 */
553 public String getString(String parameterName) throws SQLException {
554
555 return st.getString(parameterName);
556 }
557
558 /* (non-Javadoc)
559 * @see java.sql.CallableStatement#getBoolean(java.lang.String)
560 */
561 public boolean getBoolean(String parameterName) throws SQLException {
562
563 return st.getBoolean(parameterName);
564 }
565
566 /* (non-Javadoc)
567 * @see java.sql.CallableStatement#getByte(java.lang.String)
568 */
569 public byte getByte(String parameterName) throws SQLException {
570
571 return st.getByte(parameterName);
572 }
573
574 /* (non-Javadoc)
575 * @see java.sql.CallableStatement#getShort(java.lang.String)
576 */
577 public short getShort(String parameterName) throws SQLException {
578
579 return st.getShort(parameterName);
580 }
581
582 /* (non-Javadoc)
583 * @see java.sql.CallableStatement#getInt(java.lang.String)
584 */
585 public int getInt(String parameterName) throws SQLException {
586
587 return st.getInt(parameterName);
588 }
589
590 /* (non-Javadoc)
591 * @see java.sql.CallableStatement#getLong(java.lang.String)
592 */
593 public long getLong(String parameterName) throws SQLException {
594
595 return st.getLong(parameterName);
596 }
597
598 /* (non-Javadoc)
599 * @see java.sql.CallableStatement#getFloat(java.lang.String)
600 */
601 public float getFloat(String parameterName) throws SQLException {
602
603 return st.getFloat(parameterName);
604 }
605
606 /* (non-Javadoc)
607 * @see java.sql.CallableStatement#getDouble(java.lang.String)
608 */
609 public double getDouble(String parameterName) throws SQLException {
610
611 return st.getDouble(parameterName);
612 }
613
614 /* (non-Javadoc)
615 * @see java.sql.CallableStatement#getBytes(java.lang.String)
616 */
617 public byte[] getBytes(String parameterName) throws SQLException {
618
619 return st.getBytes(parameterName);
620 }
621
622 /* (non-Javadoc)
623 * @see java.sql.CallableStatement#getDate(java.lang.String)
624 */
625 public Date getDate(String parameterName) throws SQLException {
626
627 return st.getDate(parameterName);
628 }
629
630 /* (non-Javadoc)
631 * @see java.sql.CallableStatement#getTime(java.lang.String)
632 */
633 public Time getTime(String parameterName) throws SQLException {
634
635 return st.getTime(parameterName);
636 }
637
638 /* (non-Javadoc)
639 * @see java.sql.CallableStatement#getTimestamp(java.lang.String)
640 */
641 public Timestamp getTimestamp(String parameterName) throws SQLException {
642
643 return st.getTimestamp(parameterName);
644 }
645
646 /* (non-Javadoc)
647 * @see java.sql.CallableStatement#getObject(java.lang.String)
648 */
649 public Object getObject(String parameterName) throws SQLException {
650
651 return st.getObject(parameterName);
652 }
653
654 /* (non-Javadoc)
655 * @see java.sql.CallableStatement#getBigDecimal(java.lang.String)
656 */
657 public BigDecimal getBigDecimal(String parameterName) throws SQLException {
658
659 return st.getBigDecimal(parameterName);
660 }
661
662 /* (non-Javadoc)
663 * @see java.sql.CallableStatement#getObject(java.lang.String, java.util.Map)
664 */
665 public Object getObject(String parameterName, Map map)
666 throws SQLException {
667
668 return st.getObject(parameterName, map);
669 }
670
671 /* (non-Javadoc)
672 * @see java.sql.CallableStatement#getRef(java.lang.String)
673 */
674 public Ref getRef(String parameterName) throws SQLException {
675
676 return st.getRef(parameterName);
677 }
678
679 /* (non-Javadoc)
680 * @see java.sql.CallableStatement#getBlob(java.lang.String)
681 */
682 public Blob getBlob(String parameterName) throws SQLException {
683
684 return st.getBlob(parameterName);
685 }
686
687 /* (non-Javadoc)
688 * @see java.sql.CallableStatement#getClob(java.lang.String)
689 */
690 public Clob getClob(String parameterName) throws SQLException {
691
692 return st.getClob(parameterName);
693 }
694
695 /* (non-Javadoc)
696 * @see java.sql.CallableStatement#getArray(java.lang.String)
697 */
698 public Array getArray(String parameterName) throws SQLException {
699
700 return st.getArray(parameterName);
701 }
702
703 /* (non-Javadoc)
704 * @see java.sql.CallableStatement#getDate(java.lang.String, java.util.Calendar)
705 */
706 public Date getDate(String parameterName, Calendar cal)
707 throws SQLException {
708
709 return st.getDate(parameterName, cal);
710 }
711
712 /* (non-Javadoc)
713 * @see java.sql.CallableStatement#getTime(java.lang.String, java.util.Calendar)
714 */
715 public Time getTime(String parameterName, Calendar cal)
716 throws SQLException {
717
718 return st.getTime(parameterName, cal);
719 }
720
721 /* (non-Javadoc)
722 * @see java.sql.CallableStatement#getTimestamp(java.lang.String, java.util.Calendar)
723 */
724 public Timestamp getTimestamp(String parameterName, Calendar cal)
725 throws SQLException {
726
727 return st.getTimestamp(parameterName, cal);
728 }
729
730 /* (non-Javadoc)
731 * @see java.sql.CallableStatement#getURL(java.lang.String)
732 */
733 public URL getURL(String parameterName) throws SQLException {
734
735 return st.getURL(parameterName);
736 }
737
738 /* (non-Javadoc)
739 * @see java.sql.PreparedStatement#executeQuery()
740 */
741 public ResultSet executeQuery() throws SQLException {
742
743 try {
744 Survey s = new Survey();
745 ResultSet r = st.executeQuery();
746 Log.printlnSqlLog("executeQuery ", s.doEnd());
747 return r;
748 } catch (SQLException e) {
749 Log.printlnSqlExceptionLog("executeQuery ", e);
750 throw e;
751 }
752
753 //// // log
754 //// return st.executeQuery();
755 }
756
757 /* (non-Javadoc)
758 * @see java.sql.PreparedStatement#executeUpdate()
759 */
760 public int executeUpdate() throws SQLException {
761
762 try {
763 Survey s = new Survey();
764 int c = st.executeUpdate();
765 Log.printlnSqlLog("executeUpdate count " + c, s.doEnd());
766 return c;
767 } catch (SQLException e) {
768 Log.printlnSqlExceptionLog("executeUpate", e);
769 throw e;
770 }
771
772 // log
773 // return st.executeUpdate();
774 }
775
776 /* (non-Javadoc)
777 * @see java.sql.PreparedStatement#setNull(int, int)
778 */
779 public void setNull(int parameterIndex, int sqlType) throws SQLException {
780
781 st.setNull(parameterIndex, sqlType);
782 }
783
784 /* (non-Javadoc)
785 * @see java.sql.PreparedStatement#setBoolean(int, boolean)
786 */
787 public void setBoolean(int parameterIndex, boolean x) throws SQLException {
788
789 st.setBoolean(parameterIndex, x);
790 }
791
792 /* (non-Javadoc)
793 * @see java.sql.PreparedStatement#setByte(int, byte)
794 */
795 public void setByte(int parameterIndex, byte x) throws SQLException {
796
797 st.setByte(parameterIndex, x);
798 }
799
800 /* (non-Javadoc)
801 * @see java.sql.PreparedStatement#setShort(int, short)
802 */
803 public void setShort(int parameterIndex, short x) throws SQLException {
804
805 st.setShort(parameterIndex, x);
806 }
807
808 /* (non-Javadoc)
809 * @see java.sql.PreparedStatement#setInt(int, int)
810 */
811 public void setInt(int parameterIndex, int x) throws SQLException {
812
813 st.setInt(parameterIndex, x);
814 }
815
816 /* (non-Javadoc)
817 * @see java.sql.PreparedStatement#setLong(int, long)
818 */
819 public void setLong(int parameterIndex, long x) throws SQLException {
820
821 st.setLong(parameterIndex, x);
822 }
823
824 /* (non-Javadoc)
825 * @see java.sql.PreparedStatement#setFloat(int, float)
826 */
827 public void setFloat(int parameterIndex, float x) throws SQLException {
828
829 st.setFloat(parameterIndex, x);
830 }
831
832 /* (non-Javadoc)
833 * @see java.sql.PreparedStatement#setDouble(int, double)
834 */
835 public void setDouble(int parameterIndex, double x) throws SQLException {
836
837 st.setDouble(parameterIndex, x);
838 }
839
840 /* (non-Javadoc)
841 * @see java.sql.PreparedStatement#setBigDecimal(int, java.math.BigDecimal)
842 */
843 public void setBigDecimal(int parameterIndex, BigDecimal x)
844 throws SQLException {
845
846 st.setBigDecimal(parameterIndex, x);
847 }
848
849 /* (non-Javadoc)
850 * @see java.sql.PreparedStatement#setString(int, java.lang.String)
851 */
852 public void setString(int parameterIndex, String x) throws SQLException {
853
854 st.setString(parameterIndex, x);
855 }
856
857 /* (non-Javadoc)
858 * @see java.sql.PreparedStatement#setBytes(int, byte[])
859 */
860 public void setBytes(int parameterIndex, byte[] x) throws SQLException {
861
862 st.setBytes(parameterIndex, x);
863 }
864
865 /* (non-Javadoc)
866 * @see java.sql.PreparedStatement#setDate(int, java.sql.Date)
867 */
868 public void setDate(int parameterIndex, Date x) throws SQLException {
869
870 st.setDate(parameterIndex, x);
871 }
872
873 /* (non-Javadoc)
874 * @see java.sql.PreparedStatement#setTime(int, java.sql.Time)
875 */
876 public void setTime(int parameterIndex, Time x) throws SQLException {
877
878 st.setTime(parameterIndex, x);
879 }
880
881 /* (non-Javadoc)
882 * @see java.sql.PreparedStatement#setTimestamp(int, java.sql.Timestamp)
883 */
884 public void setTimestamp(int parameterIndex, Timestamp x)
885 throws SQLException {
886
887 st.setTimestamp(parameterIndex, x);
888 }
889
890 /* (non-Javadoc)
891 * @see java.sql.PreparedStatement#setAsciiStream(int, java.io.InputStream, int)
892 */
893 public void setAsciiStream(int parameterIndex, InputStream x, int length)
894 throws SQLException {
895
896 st.setAsciiStream(parameterIndex, x, length);
897 }
898
899 /**
900 * @see java.sql.PreparedStatement#setUnicodeStream(int, java.io.InputStream, int)
901 * @deprecated
902 */
903 public void setUnicodeStream(int parameterIndex, InputStream x, int length)
904 throws SQLException {
905
906 st.setUnicodeStream(parameterIndex, x, length);
907 }
908
909 /* (non-Javadoc)
910 * @see java.sql.PreparedStatement#setBinaryStream(int, java.io.InputStream, int)
911 */
912 public void setBinaryStream(int parameterIndex, InputStream x, int length)
913 throws SQLException {
914
915 st.setBinaryStream(parameterIndex, x, length);
916 }
917
918 /* (non-Javadoc)
919 * @see java.sql.PreparedStatement#clearParameters()
920 */
921 public void clearParameters() throws SQLException {
922
923 st.clearParameters();
924 }
925
926 /* (non-Javadoc)
927 * @see java.sql.PreparedStatement#setObject(int, java.lang.Object, int, int)
928 */
929 public void setObject(
930 int parameterIndex,
931 Object x,
932 int targetSqlType,
933 int scale)
934 throws SQLException {
935
936 st.setObject(parameterIndex, x, targetSqlType, scale);
937 }
938
939 /* (non-Javadoc)
940 * @see java.sql.PreparedStatement#setObject(int, java.lang.Object, int)
941 */
942 public void setObject(int parameterIndex, Object x, int targetSqlType)
943 throws SQLException {
944
945 st.setObject(parameterIndex, x, targetSqlType);
946 }
947
948 /* (non-Javadoc)
949 * @see java.sql.PreparedStatement#setObject(int, java.lang.Object)
950 */
951 public void setObject(int parameterIndex, Object x) throws SQLException {
952
953 st.setObject(parameterIndex, x);
954 }
955
956 /* (non-Javadoc)
957 * @see java.sql.PreparedStatement#execute()
958 */
959 public boolean execute() throws SQLException {
960
961 try {
962 Survey s = new Survey();
963 boolean b = st.execute();
964 Log.printlnSqlLog("execute ", s.doEnd());
965 return b;
966 } catch (SQLException e) {
967 Log.printlnSqlExceptionLog("execute ", e);
968 throw e;
969 }
970
971 //// // log
972 //// return st.execute();
973 }
974
975 /* (non-Javadoc)
976 * @see java.sql.PreparedStatement#addBatch()
977 */
978 public void addBatch() throws SQLException {
979
980 st.addBatch();
981 }
982
983 /* (non-Javadoc)
984 * @see java.sql.PreparedStatement#setCharacterStream(int, java.io.Reader, int)
985 */
986 public void setCharacterStream(
987 int parameterIndex,
988 Reader reader,
989 int length)
990 throws SQLException {
991
992 st.setCharacterStream(parameterIndex, reader, length);
993 }
994
995 /* (non-Javadoc)
996 * @see java.sql.PreparedStatement#setRef(int, java.sql.Ref)
997 */
998 public void setRef(int i, Ref x) throws SQLException {
999
1000 st.setRef(i, x);
1001 }
1002
1003 /* (non-Javadoc)
1004 * @see java.sql.PreparedStatement#setBlob(int, java.sql.Blob)
1005 */
1006 public void setBlob(int i, Blob x) throws SQLException {
1007
1008 st.setBlob(i, x);
1009 }
1010
1011 /* (non-Javadoc)
1012 * @see java.sql.PreparedStatement#setClob(int, java.sql.Clob)
1013 */
1014 public void setClob(int i, Clob x) throws SQLException {
1015
1016 st.setClob(i, x);
1017 }
1018
1019 /* (non-Javadoc)
1020 * @see java.sql.PreparedStatement#setArray(int, java.sql.Array)
1021 */
1022 public void setArray(int i, Array x) throws SQLException {
1023
1024 st.setArray(i, x);
1025 }
1026
1027 /* (non-Javadoc)
1028 * @see java.sql.PreparedStatement#getMetaData()
1029 */
1030 public ResultSetMetaData getMetaData() throws SQLException {
1031
1032 return st.getMetaData();
1033 }
1034
1035 /* (non-Javadoc)
1036 * @see java.sql.PreparedStatement#setDate(int, java.sql.Date, java.util.Calendar)
1037 */
1038 public void setDate(int parameterIndex, Date x, Calendar cal)
1039 throws SQLException {
1040
1041 st.setDate(parameterIndex, x, cal);
1042 }
1043
1044 /* (non-Javadoc)
1045 * @see java.sql.PreparedStatement#setTime(int, java.sql.Time, java.util.Calendar)
1046 */
1047 public void setTime(int parameterIndex, Time x, Calendar cal)
1048 throws SQLException {
1049
1050 st.setTime(parameterIndex, x, cal);
1051 }
1052
1053 /* (non-Javadoc)
1054 * @see java.sql.PreparedStatement#setTimestamp(int, java.sql.Timestamp, java.util.Calendar)
1055 */
1056 public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal)
1057 throws SQLException {
1058
1059 st.setTimestamp(parameterIndex, x, cal);
1060 }
1061
1062 /* (non-Javadoc)
1063 * @see java.sql.PreparedStatement#setNull(int, int, java.lang.String)
1064 */
1065 public void setNull(int paramIndex, int sqlType, String typeName)
1066 throws SQLException {
1067
1068 st.setNull(paramIndex, sqlType, typeName);
1069 }
1070
1071 /* (non-Javadoc)
1072 * @see java.sql.PreparedStatement#setURL(int, java.net.URL)
1073 */
1074 public void setURL(int parameterIndex, URL x) throws SQLException {
1075
1076 st.setURL(parameterIndex, x);
1077 }
1078
1079 /* (non-Javadoc)
1080 * @see java.sql.PreparedStatement#getParameterMetaData()
1081 */
1082 public ParameterMetaData getParameterMetaData() throws SQLException {
1083
1084 return st.getParameterMetaData();
1085 }
1086
1087 /* (non-Javadoc)
1088 * @see java.sql.Statement#executeQuery(java.lang.String)
1089 */
1090 public ResultSet executeQuery(String sql) throws SQLException {
1091
1092 return st.executeQuery();
1093 }
1094
1095 /* (non-Javadoc)
1096 * @see java.sql.Statement#executeUpdate(java.lang.String)
1097 */
1098 public int executeUpdate(String sql) throws SQLException {
1099
1100 return st.executeUpdate(sql);
1101 }
1102
1103 /* (non-Javadoc)
1104 * @see java.sql.Statement#close()
1105 */
1106 public void close() throws SQLException {
1107
1108 st.close();
1109 }
1110
1111 /* (non-Javadoc)
1112 * @see java.sql.Statement#getMaxFieldSize()
1113 */
1114 public int getMaxFieldSize() throws SQLException {
1115
1116 return st.getMaxFieldSize();
1117 }
1118
1119 /* (non-Javadoc)
1120 * @see java.sql.Statement#setMaxFieldSize(int)
1121 */
1122 public void setMaxFieldSize(int max) throws SQLException {
1123
1124 st.setMaxFieldSize(max);
1125 }
1126
1127 /* (non-Javadoc)
1128 * @see java.sql.Statement#getMaxRows()
1129 */
1130 public int getMaxRows() throws SQLException {
1131
1132 return st.getMaxRows();
1133 }
1134
1135 /* (non-Javadoc)
1136 * @see java.sql.Statement#setMaxRows(int)
1137 */
1138 public void setMaxRows(int max) throws SQLException {
1139
1140 st.setMaxRows(max);
1141 }
1142
1143 /* (non-Javadoc)
1144 * @see java.sql.Statement#setEscapeProcessing(boolean)
1145 */
1146 public void setEscapeProcessing(boolean enable) throws SQLException {
1147
1148 st.setEscapeProcessing(enable);
1149 }
1150
1151 /* (non-Javadoc)
1152 * @see java.sql.Statement#getQueryTimeout()
1153 */
1154 public int getQueryTimeout() throws SQLException {
1155
1156 return st.getQueryTimeout();
1157 }
1158
1159 /* (non-Javadoc)
1160 * @see java.sql.Statement#setQueryTimeout(int)
1161 */
1162 public void setQueryTimeout(int seconds) throws SQLException {
1163
1164 st.setQueryTimeout(seconds);
1165 }
1166
1167 /* (non-Javadoc)
1168 * @see java.sql.Statement#cancel()
1169 */
1170 public void cancel() throws SQLException {
1171
1172 st.cancel();
1173 }
1174
1175 /* (non-Javadoc)
1176 * @see java.sql.Statement#getWarnings()
1177 */
1178 public SQLWarning getWarnings() throws SQLException {
1179
1180 return st.getWarnings();
1181 }
1182
1183 /* (non-Javadoc)
1184 * @see java.sql.Statement#clearWarnings()
1185 */
1186 public void clearWarnings() throws SQLException {
1187
1188 st.clearWarnings();
1189 }
1190
1191 /* (non-Javadoc)
1192 * @see java.sql.Statement#setCursorName(java.lang.String)
1193 */
1194 public void setCursorName(String name) throws SQLException {
1195
1196 st.setCursorName(name);
1197 }
1198
1199 /* (non-Javadoc)
1200 * @see java.sql.Statement#execute(java.lang.String)
1201 */
1202 public boolean execute(String sql) throws SQLException {
1203
1204 try {
1205 Survey s = new Survey();
1206 boolean b = st.execute(sql);
1207 Log.printlnSqlLog("execute result " + b, s.doEnd());
1208 return b;
1209 } catch (SQLException e) {
1210 Log.printlnSqlExceptionLog("execute ", e);
1211 throw e;
1212 }
1213
1214 //// // AMS log
1215 //// return st.execute(sql);
1216 }
1217
1218 /* (non-Javadoc)
1219 * @see java.sql.Statement#getResultSet()
1220 */
1221 public ResultSet getResultSet() throws SQLException {
1222
1223 return st.getResultSet();
1224 }
1225
1226 /* (non-Javadoc)
1227 * @see java.sql.Statement#getUpdateCount()
1228 */
1229 public int getUpdateCount() throws SQLException {
1230
1231 return st.getUpdateCount();
1232 }
1233
1234 /* (non-Javadoc)
1235 * @see java.sql.Statement#getMoreResults()
1236 */
1237 public boolean getMoreResults() throws SQLException {
1238
1239 return st.getMoreResults();
1240 }
1241
1242 /* (non-Javadoc)
1243 * @see java.sql.Statement#setFetchDirection(int)
1244 */
1245 public void setFetchDirection(int direction) throws SQLException {
1246
1247 st.setFetchDirection(direction);
1248 }
1249
1250 /* (non-Javadoc)
1251 * @see java.sql.Statement#getFetchDirection()
1252 */
1253 public int getFetchDirection() throws SQLException {
1254
1255 return st.getFetchDirection();
1256 }
1257
1258 /* (non-Javadoc)
1259 * @see java.sql.Statement#setFetchSize(int)
1260 */
1261 public void setFetchSize(int rows) throws SQLException {
1262
1263 st.setFetchSize(rows);
1264 }
1265
1266 /* (non-Javadoc)
1267 * @see java.sql.Statement#getFetchSize()
1268 */
1269 public int getFetchSize() throws SQLException {
1270
1271 return st.getFetchSize();
1272 }
1273
1274 /* (non-Javadoc)
1275 * @see java.sql.Statement#getResultSetConcurrency()
1276 */
1277 public int getResultSetConcurrency() throws SQLException {
1278
1279 return st.getResultSetConcurrency();
1280 }
1281
1282 /* (non-Javadoc)
1283 * @see java.sql.Statement#getResultSetType()
1284 */
1285 public int getResultSetType() throws SQLException {
1286
1287 return st.getResultSetType();
1288 }
1289
1290 /* (non-Javadoc)
1291 * @see java.sql.Statement#addBatch(java.lang.String)
1292 */
1293 public void addBatch(String sql) throws SQLException {
1294
1295 st.addBatch(sql);
1296 }
1297
1298 /* (non-Javadoc)
1299 * @see java.sql.Statement#clearBatch()
1300 */
1301 public void clearBatch() throws SQLException {
1302
1303 st.clearBatch();
1304 }
1305
1306 /* (non-Javadoc)
1307 * @see java.sql.Statement#executeBatch()
1308 */
1309 public int[] executeBatch() throws SQLException {
1310
1311 return st.executeBatch();
1312 }
1313
1314 /* (non-Javadoc)
1315 * @see java.sql.Statement#getConnection()
1316 */
1317 public Connection getConnection() throws SQLException {
1318
1319 return st.getConnection();
1320 }
1321
1322 /* (non-Javadoc)
1323 * @see java.sql.Statement#getMoreResults(int)
1324 */
1325 public boolean getMoreResults(int current) throws SQLException {
1326
1327 return st.getMoreResults(current);
1328 }
1329
1330 /* (non-Javadoc)
1331 * @see java.sql.Statement#getGeneratedKeys()
1332 */
1333 public ResultSet getGeneratedKeys() throws SQLException {
1334
1335 return st.getGeneratedKeys();
1336 }
1337
1338 /* (non-Javadoc)
1339 * @see java.sql.Statement#executeUpdate(java.lang.String, int)
1340 */
1341 public int executeUpdate(String sql, int autoGeneratedKeys)
1342 throws SQLException {
1343
1344 try {
1345 Survey s = new Survey();
1346 int c = st.executeUpdate(sql, autoGeneratedKeys);
1347 Log.printlnSqlLog("executeUpdate sql " + sql + " , count " + c, s.doEnd());
1348 return c;
1349 } catch (SQLException e) {
1350 Log.printlnSqlExceptionLog("executeUpdate ", e);
1351 throw e;
1352 }
1353 //// // log
1354 //// return st.executeUpdate(sql, autoGeneratedKeys);
1355 }
1356
1357 /* (non-Javadoc)
1358 * @see java.sql.Statement#executeUpdate(java.lang.String, int[])
1359 */
1360 public int executeUpdate(String sql, int[] columnIndexes)
1361 throws SQLException {
1362
1363 try {
1364 Survey s = new Survey();
1365 int c = st.executeUpdate(sql, columnIndexes);
1366 Log.printlnSqlLog("executeUpdate sql" + sql + " , result " + c, s.doEnd());
1367 return c;
1368 } catch (SQLException e) {
1369 Log.printlnSqlExceptionLog("execute ", e);
1370 throw e;
1371 }
1372
1373 //// // log
1374 //// return st.executeUpdate(sql, columnIndexes);
1375 }
1376
1377 /* (non-Javadoc)
1378 * @see java.sql.Statement#executeUpdate(java.lang.String, java.lang.String[])
1379 */
1380 public int executeUpdate(String sql, String[] columnNames)
1381 throws SQLException {
1382 try {
1383 Survey s = new Survey();
1384 int c = st.executeUpdate(sql, columnNames);
1385 Log.printlnSqlLog("executeUpdate sql " + sql + ", result" + c, s.doEnd());
1386 return c;
1387 } catch (SQLException e) {
1388 Log.printlnSqlExceptionLog("execute ", e);
1389 throw e;
1390 }
1391 //// // log
1392 //// return st.executeUpdate(sql, columnNames);
1393 }
1394
1395 /* (non-Javadoc)
1396 * @see java.sql.Statement#execute(java.lang.String, int)
1397 */
1398 public boolean execute(String sql, int autoGeneratedKeys)
1399 throws SQLException {
1400 try {
1401 Survey s = new Survey();
1402 boolean b = st.execute(sql, autoGeneratedKeys);
1403 Log.printlnSqlLog("execute sql " + sql + ", result " + b, s.doEnd());
1404 return b;
1405 } catch (SQLException e) {
1406 Log.printlnSqlExceptionLog("execute ", e);
1407 throw e;
1408 }
1409
1410 //// // log
1411 //// return st.execute(sql, autoGeneratedKeys);
1412 }
1413
1414 /* (non-Javadoc)
1415 * @see java.sql.Statement#execute(java.lang.String, int[])
1416 */
1417 public boolean execute(String sql, int[] columnIndexes)
1418 throws SQLException {
1419
1420 try {
1421 Survey s = new Survey();
1422 boolean b = st.execute(sql, columnIndexes);
1423 Log.printlnSqlLog("execute sql " + sql + ", result " + b, s.doEnd());
1424 return b;
1425 } catch (SQLException e) {
1426 Log.printlnSqlExceptionLog("execute ", e);
1427 throw e;
1428 }
1429
1430 //// // log
1431 //// return st.execute(sql, columnIndexes);
1432 }
1433
1434 /* (non-Javadoc)
1435 * @see java.sql.Statement#execute(java.lang.String, java.lang.String[])
1436 */
1437 public boolean execute(String sql, String[] columnNames)
1438 throws SQLException {
1439
1440 try {
1441 Survey s = new Survey();
1442 boolean b = st.execute(sql, columnNames);
1443 Log.printlnSqlLog("execute sql " + sql + ", result " + b, s.doEnd());
1444 return b;
1445 } catch (SQLException e) {
1446 Log.printlnSqlExceptionLog("execute ", e);
1447 throw e;
1448 }
1449
1450 //// // log
1451 //// return st.execute(sql, columnNames);
1452 }
1453
1454 /* (non-Javadoc)
1455 * @see java.sql.Statement#getResultSetHoldability()
1456 */
1457 public int getResultSetHoldability() throws SQLException {
1458
1459 return st.getResultSetHoldability();
1460 }
1461
1462 /**
1463 * @param parameterIndex
1464 * @return
1465 * @throws SQLException
1466 * @see java.sql.CallableStatement#getCharacterStream(int)
1467 */
1468 public Reader getCharacterStream(int parameterIndex) throws SQLException {
1469 return st.getCharacterStream(parameterIndex);
1470 }
1471
1472 /**
1473 * @param parameterName
1474 * @return
1475 * @throws SQLException
1476 * @see java.sql.CallableStatement#getCharacterStream(java.lang.String)
1477 */
1478 public Reader getCharacterStream(String parameterName) throws SQLException {
1479 return st.getCharacterStream(parameterName);
1480 }
1481
1482 /**
1483 * @param parameterIndex
1484 * @return
1485 * @throws SQLException
1486 * @see java.sql.CallableStatement#getNCharacterStream(int)
1487 */
1488 public Reader getNCharacterStream(int parameterIndex) throws SQLException {
1489 return st.getNCharacterStream(parameterIndex);
1490 }
1491
1492 /**
1493 * @param parameterName
1494 * @return
1495 * @throws SQLException
1496 * @see java.sql.CallableStatement#getNCharacterStream(java.lang.String)
1497 */
1498 public Reader getNCharacterStream(String parameterName) throws SQLException {
1499 return st.getNCharacterStream(parameterName);
1500 }
1501
1502 /**
1503 * @param parameterIndex
1504 * @return
1505 * @throws SQLException
1506 * @see java.sql.CallableStatement#getNClob(int)
1507 */
1508 public NClob getNClob(int parameterIndex) throws SQLException {
1509 return st.getNClob(parameterIndex);
1510 }
1511
1512 /**
1513 * @param parameterName
1514 * @return
1515 * @throws SQLException
1516 * @see java.sql.CallableStatement#getNClob(java.lang.String)
1517 */
1518 public NClob getNClob(String parameterName) throws SQLException {
1519 return st.getNClob(parameterName);
1520 }
1521
1522 /**
1523 * @param parameterIndex
1524 * @return
1525 * @throws SQLException
1526 * @see java.sql.CallableStatement#getNString(int)
1527 */
1528 public String getNString(int parameterIndex) throws SQLException {
1529 return st.getNString(parameterIndex);
1530 }
1531
1532 /**
1533 * @param parameterName
1534 * @return
1535 * @throws SQLException
1536 * @see java.sql.CallableStatement#getNString(java.lang.String)
1537 */
1538 public String getNString(String parameterName) throws SQLException {
1539 return st.getNString(parameterName);
1540 }
1541
1542 /**
1543 * @param parameterIndex
1544 * @return
1545 * @throws SQLException
1546 * @see java.sql.CallableStatement#getRowId(int)
1547 */
1548 public RowId getRowId(int parameterIndex) throws SQLException {
1549 return st.getRowId(parameterIndex);
1550 }
1551
1552 /**
1553 * @param parameterName
1554 * @return
1555 * @throws SQLException
1556 * @see java.sql.CallableStatement#getRowId(java.lang.String)
1557 */
1558 public RowId getRowId(String parameterName) throws SQLException {
1559 return st.getRowId(parameterName);
1560 }
1561
1562 /**
1563 * @param parameterIndex
1564 * @return
1565 * @throws SQLException
1566 * @see java.sql.CallableStatement#getSQLXML(int)
1567 */
1568 public SQLXML getSQLXML(int parameterIndex) throws SQLException {
1569 return st.getSQLXML(parameterIndex);
1570 }
1571
1572 /**
1573 * @param parameterName
1574 * @return
1575 * @throws SQLException
1576 * @see java.sql.CallableStatement#getSQLXML(java.lang.String)
1577 */
1578 public SQLXML getSQLXML(String parameterName) throws SQLException {
1579 return st.getSQLXML(parameterName);
1580 }
1581
1582 /**
1583 * @return
1584 * @throws SQLException
1585 * @see java.sql.Statement#isClosed()
1586 */
1587 public boolean isClosed() throws SQLException {
1588 return st.isClosed();
1589 }
1590
1591 /**
1592 * @return
1593 * @throws SQLException
1594 * @see java.sql.Statement#isPoolable()
1595 */
1596 public boolean isPoolable() throws SQLException {
1597 return st.isPoolable();
1598 }
1599
1600 /**
1601 * @param iface
1602 * @return
1603 * @throws SQLException
1604 * @see java.sql.Wrapper#isWrapperFor(java.lang.Class)
1605 */
1606 public boolean isWrapperFor(Class<?> iface) throws SQLException {
1607 return st.isWrapperFor(iface);
1608 }
1609
1610 /**
1611 * @param parameterIndex
1612 * @param x
1613 * @param length
1614 * @throws SQLException
1615 * @see java.sql.PreparedStatement#setAsciiStream(int, java.io.InputStream, long)
1616 */
1617 public void setAsciiStream(int parameterIndex, InputStream x, long length)
1618 throws SQLException {
1619 st.setAsciiStream(parameterIndex, x, length);
1620 }
1621
1622 /**
1623 * @param parameterIndex
1624 * @param x
1625 * @throws SQLException
1626 * @see java.sql.PreparedStatement#setAsciiStream(int, java.io.InputStream)
1627 */
1628 public void setAsciiStream(int parameterIndex, InputStream x)
1629 throws SQLException {
1630 st.setAsciiStream(parameterIndex, x);
1631 }
1632
1633 /**
1634 * @param parameterName
1635 * @param x
1636 * @param length
1637 * @throws SQLException
1638 * @see java.sql.CallableStatement#setAsciiStream(java.lang.String, java.io.InputStream, long)
1639 */
1640 public void setAsciiStream(String parameterName, InputStream x, long length)
1641 throws SQLException {
1642 st.setAsciiStream(parameterName, x, length);
1643 }
1644
1645 /**
1646 * @param parameterName
1647 * @param x
1648 * @throws SQLException
1649 * @see java.sql.CallableStatement#setAsciiStream(java.lang.String, java.io.InputStream)
1650 */
1651 public void setAsciiStream(String parameterName, InputStream x)
1652 throws SQLException {
1653 st.setAsciiStream(parameterName, x);
1654 }
1655
1656 /**
1657 * @param parameterIndex
1658 * @param x
1659 * @param length
1660 * @throws SQLException
1661 * @see java.sql.PreparedStatement#setBinaryStream(int, java.io.InputStream, long)
1662 */
1663 public void setBinaryStream(int parameterIndex, InputStream x, long length)
1664 throws SQLException {
1665 st.setBinaryStream(parameterIndex, x, length);
1666 }
1667
1668 /**
1669 * @param parameterIndex
1670 * @param x
1671 * @throws SQLException
1672 * @see java.sql.PreparedStatement#setBinaryStream(int, java.io.InputStream)
1673 */
1674 public void setBinaryStream(int parameterIndex, InputStream x)
1675 throws SQLException {
1676 st.setBinaryStream(parameterIndex, x);
1677 }
1678
1679 /**
1680 * @param parameterName
1681 * @param x
1682 * @param length
1683 * @throws SQLException
1684 * @see java.sql.CallableStatement#setBinaryStream(java.lang.String, java.io.InputStream, long)
1685 */
1686 public void setBinaryStream(String parameterName, InputStream x, long length)
1687 throws SQLException {
1688 st.setBinaryStream(parameterName, x, length);
1689 }
1690
1691 /**
1692 * @param parameterName
1693 * @param x
1694 * @throws SQLException
1695 * @see java.sql.CallableStatement#setBinaryStream(java.lang.String, java.io.InputStream)
1696 */
1697 public void setBinaryStream(String parameterName, InputStream x)
1698 throws SQLException {
1699 st.setBinaryStream(parameterName, x);
1700 }
1701
1702 /**
1703 * @param parameterIndex
1704 * @param inputStream
1705 * @param length
1706 * @throws SQLException
1707 * @see java.sql.PreparedStatement#setBlob(int, java.io.InputStream, long)
1708 */
1709 public void setBlob(int parameterIndex, InputStream inputStream, long length)
1710 throws SQLException {
1711 st.setBlob(parameterIndex, inputStream, length);
1712 }
1713
1714 /**
1715 * @param parameterIndex
1716 * @param inputStream
1717 * @throws SQLException
1718 * @see java.sql.PreparedStatement#setBlob(int, java.io.InputStream)
1719 */
1720 public void setBlob(int parameterIndex, InputStream inputStream)
1721 throws SQLException {
1722 st.setBlob(parameterIndex, inputStream);
1723 }
1724
1725 /**
1726 * @param parameterName
1727 * @param x
1728 * @throws SQLException
1729 * @see java.sql.CallableStatement#setBlob(java.lang.String, java.sql.Blob)
1730 */
1731 public void setBlob(String parameterName, Blob x) throws SQLException {
1732 st.setBlob(parameterName, x);
1733 }
1734
1735 /**
1736 * @param parameterName
1737 * @param inputStream
1738 * @param length
1739 * @throws SQLException
1740 * @see java.sql.CallableStatement#setBlob(java.lang.String, java.io.InputStream, long)
1741 */
1742 public void setBlob(String parameterName, InputStream inputStream,
1743 long length) throws SQLException {
1744 st.setBlob(parameterName, inputStream, length);
1745 }
1746
1747 /**
1748 * @param parameterName
1749 * @param inputStream
1750 * @throws SQLException
1751 * @see java.sql.CallableStatement#setBlob(java.lang.String, java.io.InputStream)
1752 */
1753 public void setBlob(String parameterName, InputStream inputStream)
1754 throws SQLException {
1755 st.setBlob(parameterName, inputStream);
1756 }
1757
1758 /**
1759 * @param parameterIndex
1760 * @param reader
1761 * @param length
1762 * @throws SQLException
1763 * @see java.sql.PreparedStatement#setCharacterStream(int, java.io.Reader, long)
1764 */
1765 public void setCharacterStream(int parameterIndex, Reader reader,
1766 long length) throws SQLException {
1767 st.setCharacterStream(parameterIndex, reader, length);
1768 }
1769
1770 /**
1771 * @param parameterIndex
1772 * @param reader
1773 * @throws SQLException
1774 * @see java.sql.PreparedStatement#setCharacterStream(int, java.io.Reader)
1775 */
1776 public void setCharacterStream(int parameterIndex, Reader reader)
1777 throws SQLException {
1778 st.setCharacterStream(parameterIndex, reader);
1779 }
1780
1781 /**
1782 * @param parameterName
1783 * @param reader
1784 * @param length
1785 * @throws SQLException
1786 * @see java.sql.CallableStatement#setCharacterStream(java.lang.String, java.io.Reader, long)
1787 */
1788 public void setCharacterStream(String parameterName, Reader reader,
1789 long length) throws SQLException {
1790 st.setCharacterStream(parameterName, reader, length);
1791 }
1792
1793 /**
1794 * @param parameterName
1795 * @param reader
1796 * @throws SQLException
1797 * @see java.sql.CallableStatement#setCharacterStream(java.lang.String, java.io.Reader)
1798 */
1799 public void setCharacterStream(String parameterName, Reader reader)
1800 throws SQLException {
1801 st.setCharacterStream(parameterName, reader);
1802 }
1803
1804 /**
1805 * @param parameterIndex
1806 * @param reader
1807 * @param length
1808 * @throws SQLException
1809 * @see java.sql.PreparedStatement#setClob(int, java.io.Reader, long)
1810 */
1811 public void setClob(int parameterIndex, Reader reader, long length)
1812 throws SQLException {
1813 st.setClob(parameterIndex, reader, length);
1814 }
1815
1816 /**
1817 * @param parameterIndex
1818 * @param reader
1819 * @throws SQLException
1820 * @see java.sql.PreparedStatement#setClob(int, java.io.Reader)
1821 */
1822 public void setClob(int parameterIndex, Reader reader) throws SQLException {
1823 st.setClob(parameterIndex, reader);
1824 }
1825
1826 /**
1827 * @param parameterName
1828 * @param x
1829 * @throws SQLException
1830 * @see java.sql.CallableStatement#setClob(java.lang.String, java.sql.Clob)
1831 */
1832 public void setClob(String parameterName, Clob x) throws SQLException {
1833 st.setClob(parameterName, x);
1834 }
1835
1836 /**
1837 * @param parameterName
1838 * @param reader
1839 * @param length
1840 * @throws SQLException
1841 * @see java.sql.CallableStatement#setClob(java.lang.String, java.io.Reader, long)
1842 */
1843 public void setClob(String parameterName, Reader reader, long length)
1844 throws SQLException {
1845 st.setClob(parameterName, reader, length);
1846 }
1847
1848 /**
1849 * @param parameterName
1850 * @param reader
1851 * @throws SQLException
1852 * @see java.sql.CallableStatement#setClob(java.lang.String, java.io.Reader)
1853 */
1854 public void setClob(String parameterName, Reader reader)
1855 throws SQLException {
1856 st.setClob(parameterName, reader);
1857 }
1858
1859 /**
1860 * @param parameterIndex
1861 * @param value
1862 * @param length
1863 * @throws SQLException
1864 * @see java.sql.PreparedStatement#setNCharacterStream(int, java.io.Reader, long)
1865 */
1866 public void setNCharacterStream(int parameterIndex, Reader value,
1867 long length) throws SQLException {
1868 st.setNCharacterStream(parameterIndex, value, length);
1869 }
1870
1871 /**
1872 * @param parameterIndex
1873 * @param value
1874 * @throws SQLException
1875 * @see java.sql.PreparedStatement#setNCharacterStream(int, java.io.Reader)
1876 */
1877 public void setNCharacterStream(int parameterIndex, Reader value)
1878 throws SQLException {
1879 st.setNCharacterStream(parameterIndex, value);
1880 }
1881
1882 /**
1883 * @param parameterName
1884 * @param value
1885 * @param length
1886 * @throws SQLException
1887 * @see java.sql.CallableStatement#setNCharacterStream(java.lang.String, java.io.Reader, long)
1888 */
1889 public void setNCharacterStream(String parameterName, Reader value,
1890 long length) throws SQLException {
1891 st.setNCharacterStream(parameterName, value, length);
1892 }
1893
1894 /**
1895 * @param parameterName
1896 * @param value
1897 * @throws SQLException
1898 * @see java.sql.CallableStatement#setNCharacterStream(java.lang.String, java.io.Reader)
1899 */
1900 public void setNCharacterStream(String parameterName, Reader value)
1901 throws SQLException {
1902 st.setNCharacterStream(parameterName, value);
1903 }
1904
1905 /**
1906 * @param parameterIndex
1907 * @param value
1908 * @throws SQLException
1909 * @see java.sql.PreparedStatement#setNClob(int, java.sql.NClob)
1910 */
1911 public void setNClob(int parameterIndex, NClob value) throws SQLException {
1912 st.setNClob(parameterIndex, value);
1913 }
1914
1915 /**
1916 * @param parameterIndex
1917 * @param reader
1918 * @param length
1919 * @throws SQLException
1920 * @see java.sql.PreparedStatement#setNClob(int, java.io.Reader, long)
1921 */
1922 public void setNClob(int parameterIndex, Reader reader, long length)
1923 throws SQLException {
1924 st.setNClob(parameterIndex, reader, length);
1925 }
1926
1927 /**
1928 * @param parameterIndex
1929 * @param reader
1930 * @throws SQLException
1931 * @see java.sql.PreparedStatement#setNClob(int, java.io.Reader)
1932 */
1933 public void setNClob(int parameterIndex, Reader reader) throws SQLException {
1934 st.setNClob(parameterIndex, reader);
1935 }
1936
1937 /**
1938 * @param parameterName
1939 * @param value
1940 * @throws SQLException
1941 * @see java.sql.CallableStatement#setNClob(java.lang.String, java.sql.NClob)
1942 */
1943 public void setNClob(String parameterName, NClob value) throws SQLException {
1944 st.setNClob(parameterName, value);
1945 }
1946
1947 /**
1948 * @param parameterName
1949 * @param reader
1950 * @param length
1951 * @throws SQLException
1952 * @see java.sql.CallableStatement#setNClob(java.lang.String, java.io.Reader, long)
1953 */
1954 public void setNClob(String parameterName, Reader reader, long length)
1955 throws SQLException {
1956 st.setNClob(parameterName, reader, length);
1957 }
1958
1959 /**
1960 * @param parameterName
1961 * @param reader
1962 * @throws SQLException
1963 * @see java.sql.CallableStatement#setNClob(java.lang.String, java.io.Reader)
1964 */
1965 public void setNClob(String parameterName, Reader reader)
1966 throws SQLException {
1967 st.setNClob(parameterName, reader);
1968 }
1969
1970 /**
1971 * @param parameterIndex
1972 * @param value
1973 * @throws SQLException
1974 * @see java.sql.PreparedStatement#setNString(int, java.lang.String)
1975 */
1976 public void setNString(int parameterIndex, String value)
1977 throws SQLException {
1978 st.setNString(parameterIndex, value);
1979 }
1980
1981 /**
1982 * @param parameterName
1983 * @param value
1984 * @throws SQLException
1985 * @see java.sql.CallableStatement#setNString(java.lang.String, java.lang.String)
1986 */
1987 public void setNString(String parameterName, String value)
1988 throws SQLException {
1989 st.setNString(parameterName, value);
1990 }
1991
1992 /**
1993 * @param poolable
1994 * @throws SQLException
1995 * @see java.sql.Statement#setPoolable(boolean)
1996 */
1997 public void setPoolable(boolean poolable) throws SQLException {
1998 st.setPoolable(poolable);
1999 }
2000
2001 /**
2002 * @param parameterIndex
2003 * @param x
2004 * @throws SQLException
2005 * @see java.sql.PreparedStatement#setRowId(int, java.sql.RowId)
2006 */
2007 public void setRowId(int parameterIndex, RowId x) throws SQLException {
2008 st.setRowId(parameterIndex, x);
2009 }
2010
2011 /**
2012 * @param parameterName
2013 * @param x
2014 * @throws SQLException
2015 * @see java.sql.CallableStatement#setRowId(java.lang.String, java.sql.RowId)
2016 */
2017 public void setRowId(String parameterName, RowId x) throws SQLException {
2018 st.setRowId(parameterName, x);
2019 }
2020
2021 /**
2022 * @param parameterIndex
2023 * @param xmlObject
2024 * @throws SQLException
2025 * @see java.sql.PreparedStatement#setSQLXML(int, java.sql.SQLXML)
2026 */
2027 public void setSQLXML(int parameterIndex, SQLXML xmlObject)
2028 throws SQLException {
2029 st.setSQLXML(parameterIndex, xmlObject);
2030 }
2031
2032 /**
2033 * @param parameterName
2034 * @param xmlObject
2035 * @throws SQLException
2036 * @see java.sql.CallableStatement#setSQLXML(java.lang.String, java.sql.SQLXML)
2037 */
2038 public void setSQLXML(String parameterName, SQLXML xmlObject)
2039 throws SQLException {
2040 st.setSQLXML(parameterName, xmlObject);
2041 }
2042
2043 /**
2044 * @param <T>
2045 * @param iface
2046 * @return
2047 * @throws SQLException
2048 * @see java.sql.Wrapper#unwrap(java.lang.Class)
2049 */
2050 public <T> T unwrap(Class<T> iface) throws SQLException {
2051 return st.unwrap(iface);
2052 }
2053
2054 }
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help