Clover coverage report - brownies library - 1.0-beta-1 Coverage timestamp: 月 8 16 2004 17:14:42 GMT+09:00 FRAMES NO FRAMES |
file stats: | LOC: | 849 |  | Methods: | 83
| NCLOC: | 320 |  | Classes: | 1
30 day Evaluation Version distributed via the Maven Jar Repository. Clover is not free. You have 30 days to evaluate it. Please visit http://www.thecortex.net/clover to obtain a licensed version of Clover
Source file | Conditionals | Statements | Methods | TOTAL
LogCallableStatement.java | 0% | 0% | 0% | 0% |

1 |  |
     /*
2 |  |
      * Joey and its relative products are published under the terms
3 |  |
      * of the Apache Software License.
4 |  |
      */
5 |  |
     /*
6 |  |
      * Created on 2004/03/01
7 |  |
      */
8 |  |
     package org.asyrinx.brownie.jdbc.logger;
9 |  |
10 |  |
     import java.io.InputStream;
11 |  |
     import java.io.Reader;
12 |  |
     import java.math.BigDecimal;
13 |  |
     import java.net.URL;
14 |  |
     import java.sql.Array;
15 |  |
     import java.sql.Blob;
16 |  |
     import java.sql.CallableStatement;
17 |  |
     import java.sql.Clob;
18 |  |
     import java.sql.Date;
19 |  |
     import java.sql.Ref;
20 |  |
     import java.sql.SQLException;
21 |  |
     import java.sql.Time;
22 |  |
     import java.sql.Timestamp;
23 |  |
     import java.util.Calendar;
24 |  |
     import java.util.HashMap;
25 |  |
     import java.util.Map;
26 |  |
27 |  |
     import org.asyrinx.brownie.core.collection.MapUtils;
28 |  |
     import org.asyrinx.brownie.core.collection.StringKeyMap;
29 |  |
     import org.asyrinx.brownie.core.log.CascadeNamedLog;
30 |  |
31 |  |
     /**
32 |  |
      * @author akima
33 |  |
      */
34 |  |
     public class LogCallableStatement extends LogPreparedStatement implements
35 |  |
             CallableStatement {
36 |  |
         /**
37 |  |
          * @param wrapped
38 |  |
          */
39 | 0 |
         public LogCallableStatement(CallableStatement wrapped, String sql,
40 |  |
                 CascadeNamedLog parentLog) {
41 | 0 |
             super(wrapped, sql, parentLog);
42 | 0 |
             this.wrapped = wrapped;
43 |  |
         }
44 |  |
45 |  |
         private final CallableStatement wrapped;
46 |  |
47 |  |
         private final StringKeyMap parameters = MapUtils
48 |  |
                 .toStringKeyMap(new HashMap());
49 |  |
50 | 0 |
         protected final void addParam(String paramName, Object value) {
51 | 0 |
             parameters.put(paramName, value);
52 |  |
         }
53 |  |
54 | 0 |
         protected String formatSql() {
55 |  |
             //パラメータ名で指定されてなかったら番号で指定されたものとしてSQLを編集
56 | 0 |
             if (this.parameters.isEmpty())
57 | 0 |
                 return super.formatSql();
58 |  |
             else
59 | 0 |
                 return replacer.execute(this.sql, this.parameters);
60 |  |
         }
61 |  |
62 |  |
         /**
63 |  |
          * @throws java.sql.SQLException
64 |  |
          */
65 | 0 |
         public void clearParameters() throws SQLException {
66 | 0 |
             super.clearParameters();
67 | 0 |
             parameters.clear();
68 |  |
         }
69 |  |
70 |  |
         /**
71 |  |
          * @param i
72 |  |
          * @return @throws
73 |  |
          *         java.sql.SQLException
74 |  |
          */
75 | 0 |
         public Array getArray(int parameterIndex) throws SQLException {
76 | 0 |
             return wrapped.getArray(parameterIndex);
77 |  |
         }
78 |  |
79 |  |
         /**
80 |  |
          * @param parameterName
81 |  |
          * @return @throws
82 |  |
          *         java.sql.SQLException
83 |  |
          */
84 | 0 |
         public Array getArray(String parameterName) throws SQLException {
85 | 0 |
             return wrapped.getArray(parameterName);
86 |  |
         }
87 |  |
88 |  |
         /**
89 |  |
          * @param parameterIndex
90 |  |
          * @return @throws
91 |  |
          *         java.sql.SQLException
92 |  |
          */
93 | 0 |
         public BigDecimal getBigDecimal(int parameterIndex) throws SQLException {
94 | 0 |
             return wrapped.getBigDecimal(parameterIndex);
95 |  |
         }
96 |  |
97 |  |
         /**
98 |  |
          * @param parameterIndex
99 |  |
          * @param scale
100 |  |
          * @return @throws
101 |  |
          *         java.sql.SQLException
102 |  |
          * @deprecated
103 |  |
          */
104 | 0 |
         public BigDecimal getBigDecimal(int parameterIndex, int scale)
105 |  |
                 throws SQLException {
106 | 0 |
             return wrapped.getBigDecimal(parameterIndex, scale);
107 |  |
         }
108 |  |
109 |  |
         /**
110 |  |
          * @param parameterName
111 |  |
          * @return @throws
112 |  |
          *         java.sql.SQLException
113 |  |
          */
114 | 0 |
         public BigDecimal getBigDecimal(String parameterName) throws SQLException {
115 | 0 |
             return wrapped.getBigDecimal(parameterName);
116 |  |
         }
117 |  |
118 |  |
         /**
119 |  |
          * @param i
120 |  |
          * @return @throws
121 |  |
          *         java.sql.SQLException
122 |  |
          */
123 | 0 |
         public Blob getBlob(int parameterIndex) throws SQLException {
124 | 0 |
             return wrapped.getBlob(parameterIndex);
125 |  |
         }
126 |  |
127 |  |
         /**
128 |  |
          * @param parameterName
129 |  |
          * @return @throws
130 |  |
          *         java.sql.SQLException
131 |  |
          */
132 | 0 |
         public Blob getBlob(String parameterName) throws SQLException {
133 | 0 |
             return wrapped.getBlob(parameterName);
134 |  |
         }
135 |  |
136 |  |
         /**
137 |  |
          * @param parameterIndex
138 |  |
          * @return @throws
139 |  |
          *         java.sql.SQLException
140 |  |
          */
141 | 0 |
         public boolean getBoolean(int parameterIndex) throws SQLException {
142 | 0 |
             return wrapped.getBoolean(parameterIndex);
143 |  |
         }
144 |  |
145 |  |
         /**
146 |  |
          * @param parameterName
147 |  |
          * @return @throws
148 |  |
          *         java.sql.SQLException
149 |  |
          */
150 | 0 |
         public boolean getBoolean(String parameterName) throws SQLException {
151 | 0 |
             return wrapped.getBoolean(parameterName);
152 |  |
         }
153 |  |
154 |  |
         /**
155 |  |
          * @param parameterIndex
156 |  |
          * @return @throws
157 |  |
          *         java.sql.SQLException
158 |  |
          */
159 | 0 |
         public byte getByte(int parameterIndex) throws SQLException {
160 | 0 |
             return wrapped.getByte(parameterIndex);
161 |  |
         }
162 |  |
163 |  |
         /**
164 |  |
          * @param parameterName
165 |  |
          * @return @throws
166 |  |
          *         java.sql.SQLException
167 |  |
          */
168 | 0 |
         public byte getByte(String parameterName) throws SQLException {
169 | 0 |
             return wrapped.getByte(parameterName);
170 |  |
         }
171 |  |
172 |  |
         /**
173 |  |
          * @param parameterIndex
174 |  |
          * @return @throws
175 |  |
          *         java.sql.SQLException
176 |  |
          */
177 | 0 |
         public byte[] getBytes(int parameterIndex) throws SQLException {
178 | 0 |
             return wrapped.getBytes(parameterIndex);
179 |  |
         }
180 |  |
181 |  |
         /**
182 |  |
          * @param parameterName
183 |  |
          * @return @throws
184 |  |
          *         java.sql.SQLException
185 |  |
          */
186 | 0 |
         public byte[] getBytes(String parameterName) throws SQLException {
187 | 0 |
             return wrapped.getBytes(parameterName);
188 |  |
         }
189 |  |
190 |  |
         /**
191 |  |
          * @param i
192 |  |
          * @return @throws
193 |  |
          *         java.sql.SQLException
194 |  |
          */
195 | 0 |
         public Clob getClob(int parameterIndex) throws SQLException {
196 | 0 |
             return wrapped.getClob(parameterIndex);
197 |  |
         }
198 |  |
199 |  |
         /**
200 |  |
          * @param parameterName
201 |  |
          * @return @throws
202 |  |
          *         java.sql.SQLException
203 |  |
          */
204 | 0 |
         public Clob getClob(String parameterName) throws SQLException {
205 | 0 |
             return wrapped.getClob(parameterName);
206 |  |
         }
207 |  |
208 |  |
         /**
209 |  |
          * @param parameterIndex
210 |  |
          * @return @throws
211 |  |
          *         java.sql.SQLException
212 |  |
          */
213 | 0 |
         public Date getDate(int parameterIndex) throws SQLException {
214 | 0 |
             return wrapped.getDate(parameterIndex);
215 |  |
         }
216 |  |
217 |  |
         /**
218 |  |
          * @param parameterIndex
219 |  |
          * @param cal
220 |  |
          * @return @throws
221 |  |
          *         java.sql.SQLException
222 |  |
          */
223 | 0 |
         public Date getDate(int parameterIndex, Calendar cal) throws SQLException {
224 | 0 |
             return wrapped.getDate(parameterIndex, cal);
225 |  |
         }
226 |  |
227 |  |
         /**
228 |  |
          * @param parameterName
229 |  |
          * @return @throws
230 |  |
          *         java.sql.SQLException
231 |  |
          */
232 | 0 |
         public Date getDate(String parameterName) throws SQLException {
233 | 0 |
             return wrapped.getDate(parameterName);
234 |  |
         }
235 |  |
236 |  |
         /**
237 |  |
          * @param parameterName
238 |  |
          * @param cal
239 |  |
          * @return @throws
240 |  |
          *         java.sql.SQLException
241 |  |
          */
242 | 0 |
         public Date getDate(String parameterName, Calendar cal) throws SQLException {
243 | 0 |
             return wrapped.getDate(parameterName, cal);
244 |  |
         }
245 |  |
246 |  |
         /**
247 |  |
          * @param parameterIndex
248 |  |
          * @return @throws
249 |  |
          *         java.sql.SQLException
250 |  |
          */
251 | 0 |
         public double getDouble(int parameterIndex) throws SQLException {
252 | 0 |
             return wrapped.getDouble(parameterIndex);
253 |  |
         }
254 |  |
255 |  |
         /**
256 |  |
          * @param parameterName
257 |  |
          * @return @throws
258 |  |
          *         java.sql.SQLException
259 |  |
          */
260 | 0 |
         public double getDouble(String parameterName) throws SQLException {
261 | 0 |
             return wrapped.getDouble(parameterName);
262 |  |
         }
263 |  |
264 |  |
         /**
265 |  |
          * @param parameterIndex
266 |  |
          * @return @throws
267 |  |
          *         java.sql.SQLException
268 |  |
          */
269 | 0 |
         public float getFloat(int parameterIndex) throws SQLException {
270 | 0 |
             return wrapped.getFloat(parameterIndex);
271 |  |
         }
272 |  |
273 |  |
         /**
274 |  |
          * @param parameterName
275 |  |
          * @return @throws
276 |  |
          *         java.sql.SQLException
277 |  |
          */
278 | 0 |
         public float getFloat(String parameterName) throws SQLException {
279 | 0 |
             return wrapped.getFloat(parameterName);
280 |  |
         }
281 |  |
282 |  |
         /**
283 |  |
          * @param parameterIndex
284 |  |
          * @return @throws
285 |  |
          *         java.sql.SQLException
286 |  |
          */
287 | 0 |
         public int getInt(int parameterIndex) throws SQLException {
288 | 0 |
             return wrapped.getInt(parameterIndex);
289 |  |
         }
290 |  |
291 |  |
         /**
292 |  |
          * @param parameterName
293 |  |
          * @return @throws
294 |  |
          *         java.sql.SQLException
295 |  |
          */
296 | 0 |
         public int getInt(String parameterName) throws SQLException {
297 | 0 |
             return wrapped.getInt(parameterName);
298 |  |
         }
299 |  |
300 |  |
         /**
301 |  |
          * @param parameterIndex
302 |  |
          * @return @throws
303 |  |
          *         java.sql.SQLException
304 |  |
          */
305 | 0 |
         public long getLong(int parameterIndex) throws SQLException {
306 | 0 |
             return wrapped.getLong(parameterIndex);
307 |  |
         }
308 |  |
309 |  |
         /**
310 |  |
          * @param parameterName
311 |  |
          * @return @throws
312 |  |
          *         java.sql.SQLException
313 |  |
          */
314 | 0 |
         public long getLong(String parameterName) throws SQLException {
315 | 0 |
             return wrapped.getLong(parameterName);
316 |  |
         }
317 |  |
318 |  |
         /**
319 |  |
          * @param parameterIndex
320 |  |
          * @return @throws
321 |  |
          *         java.sql.SQLException
322 |  |
          */
323 | 0 |
         public Object getObject(int parameterIndex) throws SQLException {
324 | 0 |
             return wrapped.getObject(parameterIndex);
325 |  |
         }
326 |  |
327 |  |
         /**
328 |  |
          * @param i
329 |  |
          * @param map
330 |  |
          * @return @throws
331 |  |
          *         java.sql.SQLException
332 |  |
          */
333 | 0 |
         public Object getObject(int parameterIndex, Map map) throws SQLException {
334 | 0 |
             return wrapped.getObject(parameterIndex, map);
335 |  |
         }
336 |  |
337 |  |
         /**
338 |  |
          * @param parameterName
339 |  |
          * @return @throws
340 |  |
          *         java.sql.SQLException
341 |  |
          */
342 | 0 |
         public Object getObject(String parameterName) throws SQLException {
343 | 0 |
             return wrapped.getObject(parameterName);
344 |  |
         }
345 |  |
346 |  |
         /**
347 |  |
          * @param parameterName
348 |  |
          * @param map
349 |  |
          * @return @throws
350 |  |
          *         java.sql.SQLException
351 |  |
          */
352 | 0 |
         public Object getObject(String parameterName, Map map) throws SQLException {
353 | 0 |
             return wrapped.getObject(parameterName, map);
354 |  |
         }
355 |  |
356 |  |
         /**
357 |  |
          * @param i
358 |  |
          * @return @throws
359 |  |
          *         java.sql.SQLException
360 |  |
          */
361 | 0 |
         public Ref getRef(int parameterIndex) throws SQLException {
362 | 0 |
             return wrapped.getRef(parameterIndex);
363 |  |
         }
364 |  |
365 |  |
         /**
366 |  |
          * @param parameterName
367 |  |
          * @return @throws
368 |  |
          *         java.sql.SQLException
369 |  |
          */
370 | 0 |
         public Ref getRef(String parameterName) throws SQLException {
371 | 0 |
             return wrapped.getRef(parameterName);
372 |  |
         }
373 |  |
374 |  |
         /**
375 |  |
          * @param parameterIndex
376 |  |
          * @return @throws
377 |  |
          *         java.sql.SQLException
378 |  |
          */
379 | 0 |
         public short getShort(int parameterIndex) throws SQLException {
380 | 0 |
             return wrapped.getShort(parameterIndex);
381 |  |
         }
382 |  |
383 |  |
         /**
384 |  |
          * @param parameterName
385 |  |
          * @return @throws
386 |  |
          *         java.sql.SQLException
387 |  |
          */
388 | 0 |
         public short getShort(String parameterName) throws SQLException {
389 | 0 |
             return wrapped.getShort(parameterName);
390 |  |
         }
391 |  |
392 |  |
         /**
393 |  |
          * @param parameterIndex
394 |  |
          * @return @throws
395 |  |
          *         java.sql.SQLException
396 |  |
          */
397 | 0 |
         public String getString(int parameterIndex) throws SQLException {
398 | 0 |
             return wrapped.getString(parameterIndex);
399 |  |
         }
400 |  |
401 |  |
         /**
402 |  |
          * @param parameterName
403 |  |
          * @return @throws
404 |  |
          *         java.sql.SQLException
405 |  |
          */
406 | 0 |
         public String getString(String parameterName) throws SQLException {
407 | 0 |
             return wrapped.getString(parameterName);
408 |  |
         }
409 |  |
410 |  |
         /**
411 |  |
          * @param parameterIndex
412 |  |
          * @return @throws
413 |  |
          *         java.sql.SQLException
414 |  |
          */
415 | 0 |
         public Time getTime(int parameterIndex) throws SQLException {
416 | 0 |
             return wrapped.getTime(parameterIndex);
417 |  |
         }
418 |  |
419 |  |
         /**
420 |  |
          * @param parameterIndex
421 |  |
          * @param cal
422 |  |
          * @return @throws
423 |  |
          *         java.sql.SQLException
424 |  |
          */
425 | 0 |
         public Time getTime(int parameterIndex, Calendar cal) throws SQLException {
426 | 0 |
             return wrapped.getTime(parameterIndex, cal);
427 |  |
         }
428 |  |
429 |  |
         /**
430 |  |
          * @param parameterName
431 |  |
          * @return @throws
432 |  |
          *         java.sql.SQLException
433 |  |
          */
434 | 0 |
         public Time getTime(String parameterName) throws SQLException {
435 | 0 |
             return wrapped.getTime(parameterName);
436 |  |
         }
437 |  |
438 |  |
         /**
439 |  |
          * @param parameterName
440 |  |
          * @param cal
441 |  |
          * @return @throws
442 |  |
          *         java.sql.SQLException
443 |  |
          */
444 | 0 |
         public Time getTime(String parameterName, Calendar cal) throws SQLException {
445 | 0 |
             return wrapped.getTime(parameterName, cal);
446 |  |
         }
447 |  |
448 |  |
         /**
449 |  |
          * @param parameterIndex
450 |  |
          * @return @throws
451 |  |
          *         java.sql.SQLException
452 |  |
          */
453 | 0 |
         public Timestamp getTimestamp(int parameterIndex) throws SQLException {
454 | 0 |
             return wrapped.getTimestamp(parameterIndex);
455 |  |
         }
456 |  |
457 |  |
         /**
458 |  |
          * @param parameterIndex
459 |  |
          * @param cal
460 |  |
          * @return @throws
461 |  |
          *         java.sql.SQLException
462 |  |
          */
463 | 0 |
         public Timestamp getTimestamp(int parameterIndex, Calendar cal)
464 |  |
                 throws SQLException {
465 | 0 |
             return wrapped.getTimestamp(parameterIndex, cal);
466 |  |
         }
467 |  |
468 |  |
         /**
469 |  |
          * @param parameterName
470 |  |
          * @return @throws
471 |  |
          *         java.sql.SQLException
472 |  |
          */
473 | 0 |
         public Timestamp getTimestamp(String parameterName) throws SQLException {
474 | 0 |
             return wrapped.getTimestamp(parameterName);
475 |  |
         }
476 |  |
477 |  |
         /**
478 |  |
          * @param parameterName
479 |  |
          * @param cal
480 |  |
          * @return @throws
481 |  |
          *         java.sql.SQLException
482 |  |
          */
483 | 0 |
         public Timestamp getTimestamp(String parameterName, Calendar cal)
484 |  |
                 throws SQLException {
485 | 0 |
             return wrapped.getTimestamp(parameterName, cal);
486 |  |
         }
487 |  |
488 |  |
         /**
489 |  |
          * @param parameterIndex
490 |  |
          * @return @throws
491 |  |
          *         java.sql.SQLException
492 |  |
          */
493 | 0 |
         public URL getURL(int parameterIndex) throws SQLException {
494 | 0 |
             return wrapped.getURL(parameterIndex);
495 |  |
         }
496 |  |
497 |  |
         /**
498 |  |
          * @param parameterName
499 |  |
          * @return @throws
500 |  |
          *         java.sql.SQLException
501 |  |
          */
502 | 0 |
         public URL getURL(String parameterName) throws SQLException {
503 | 0 |
             return wrapped.getURL(parameterName);
504 |  |
         }
505 |  |
506 |  |
         /**
507 |  |
          * @param parameterIndex
508 |  |
          * @param sqlType
509 |  |
          * @throws java.sql.SQLException
510 |  |
          */
511 | 0 |
         public void registerOutParameter(int parameterIndex, int sqlType)
512 |  |
                 throws SQLException {
513 | 0 |
             wrapped.registerOutParameter(parameterIndex, sqlType);
514 |  |
         }
515 |  |
516 |  |
         /**
517 |  |
          * @param parameterIndex
518 |  |
          * @param sqlType
519 |  |
          * @param scale
520 |  |
          * @throws java.sql.SQLException
521 |  |
          */
522 | 0 |
         public void registerOutParameter(int parameterIndex, int sqlType, int scale)
523 |  |
                 throws SQLException {
524 | 0 |
             wrapped.registerOutParameter(parameterIndex, sqlType, scale);
525 |  |
         }
526 |  |
527 |  |
         /**
528 |  |
          * @param paramIndex
529 |  |
          * @param sqlType
530 |  |
          * @param typeName
531 |  |
          * @throws java.sql.SQLException
532 |  |
          */
533 | 0 |
         public void registerOutParameter(int paramIndex, int sqlType,
534 |  |
                 String typeName) throws SQLException {
535 | 0 |
             wrapped.registerOutParameter(paramIndex, sqlType, typeName);
536 |  |
         }
537 |  |
538 |  |
         /**
539 |  |
          * @param parameterName
540 |  |
          * @param sqlType
541 |  |
          * @throws java.sql.SQLException
542 |  |
          */
543 | 0 |
         public void registerOutParameter(String parameterName, int sqlType)
544 |  |
                 throws SQLException {
545 | 0 |
             wrapped.registerOutParameter(parameterName, sqlType);
546 |  |
         }
547 |  |
548 |  |
         /**
549 |  |
          * @param parameterName
550 |  |
          * @param sqlType
551 |  |
          * @param scale
552 |  |
          * @throws java.sql.SQLException
553 |  |
          */
554 | 0 |
         public void registerOutParameter(String parameterName, int sqlType,
555 |  |
                 int scale) throws SQLException {
556 | 0 |
             wrapped.registerOutParameter(parameterName, sqlType, scale);
557 |  |
         }
558 |  |
559 |  |
         /**
560 |  |
          * @param parameterName
561 |  |
          * @param sqlType
562 |  |
          * @param typeName
563 |  |
          * @throws java.sql.SQLException
564 |  |
          */
565 | 0 |
         public void registerOutParameter(String parameterName, int sqlType,
566 |  |
                 String typeName) throws SQLException {
567 | 0 |
             wrapped.registerOutParameter(parameterName, sqlType, typeName);
568 |  |
         }
569 |  |
570 |  |
         /**
571 |  |
          * @param parameterName
572 |  |
          * @param x
573 |  |
          * @param length
574 |  |
          * @throws java.sql.SQLException
575 |  |
          */
576 | 0 |
         public void setAsciiStream(String parameterName, InputStream x, int length)
577 |  |
                 throws SQLException {
578 | 0 |
             wrapped.setAsciiStream(parameterName, x, length);
579 |  |
             //addParam(parameterName, x);
580 |  |
         }
581 |  |
582 |  |
         /**
583 |  |
          * @param parameterName
584 |  |
          * @param x
585 |  |
          * @throws java.sql.SQLException
586 |  |
          */
587 | 0 |
         public void setBigDecimal(String parameterName, BigDecimal x)
588 |  |
                 throws SQLException {
589 | 0 |
             wrapped.setBigDecimal(parameterName, x);
590 | 0 |
             addParam(parameterName, x);
591 |  |
         }
592 |  |
593 |  |
         /**
594 |  |
          * @param parameterName
595 |  |
          * @param x
596 |  |
          * @param length
597 |  |
          * @throws java.sql.SQLException
598 |  |
          */
599 | 0 |
         public void setBinaryStream(String parameterName, InputStream x, int length)
600 |  |
                 throws SQLException {
601 | 0 |
             wrapped.setBinaryStream(parameterName, x, length);
602 |  |
             //addParam(parameterName, x);
603 |  |
         }
604 |  |
605 |  |
         /**
606 |  |
          * @param parameterName
607 |  |
          * @param x
608 |  |
          * @throws java.sql.SQLException
609 |  |
          */
610 | 0 |
         public void setBoolean(String parameterName, boolean x) throws SQLException {
611 | 0 |
             wrapped.setBoolean(parameterName, x);
612 | 0 |
             addParam(parameterName, new Boolean(x));
613 |  |
         }
614 |  |
615 |  |
         /**
616 |  |
          * @param parameterName
617 |  |
          * @param x
618 |  |
          * @throws java.sql.SQLException
619 |  |
          */
620 | 0 |
         public void setByte(String parameterName, byte x) throws SQLException {
621 | 0 |
             wrapped.setByte(parameterName, x);
622 | 0 |
             addParam(parameterName, new Byte(x));
623 |  |
         }
624 |  |
625 |  |
         /**
626 |  |
          * @param parameterName
627 |  |
          * @param x
628 |  |
          * @throws java.sql.SQLException
629 |  |
          */
630 | 0 |
         public void setBytes(String parameterName, byte[] x) throws SQLException {
631 | 0 |
             wrapped.setBytes(parameterName, x);
632 | 0 |
             addParam(parameterName, x);
633 |  |
         }
634 |  |
635 |  |
         /**
636 |  |
          * @param parameterName
637 |  |
          * @param reader
638 |  |
          * @param length
639 |  |
          * @throws java.sql.SQLException
640 |  |
          */
641 | 0 |
         public void setCharacterStream(String parameterName, Reader reader,
642 |  |
                 int length) throws SQLException {
643 | 0 |
             wrapped.setCharacterStream(parameterName, reader, length);
644 |  |
             //addParam(parameterName, x);
645 |  |
         }
646 |  |
647 |  |
         /**
648 |  |
          * @param parameterName
649 |  |
          * @param x
650 |  |
          * @throws java.sql.SQLException
651 |  |
          */
652 | 0 |
         public void setDate(String parameterName, Date x) throws SQLException {
653 | 0 |
             wrapped.setDate(parameterName, x);
654 | 0 |
             addParam(parameterName, x);
655 |  |
         }
656 |  |
657 |  |
         /**
658 |  |
          * @param parameterName
659 |  |
          * @param x
660 |  |
          * @param cal
661 |  |
          * @throws java.sql.SQLException
662 |  |
          */
663 | 0 |
         public void setDate(String parameterName, Date x, Calendar cal)
664 |  |
                 throws SQLException {
665 | 0 |
             wrapped.setDate(parameterName, x, cal);
666 | 0 |
             addParam(parameterName, x);
667 |  |
         }
668 |  |
669 |  |
         /**
670 |  |
          * @param parameterName
671 |  |
          * @param x
672 |  |
          * @throws java.sql.SQLException
673 |  |
          */
674 | 0 |
         public void setDouble(String parameterName, double x) throws SQLException {
675 | 0 |
             wrapped.setDouble(parameterName, x);
676 | 0 |
             addParam(parameterName, new Double(x));
677 |  |
         }
678 |  |
679 |  |
         /**
680 |  |
          * @param parameterName
681 |  |
          * @param x
682 |  |
          * @throws java.sql.SQLException
683 |  |
          */
684 | 0 |
         public void setFloat(String parameterName, float x) throws SQLException {
685 | 0 |
             wrapped.setFloat(parameterName, x);
686 | 0 |
             addParam(parameterName, new Float(x));
687 |  |
         }
688 |  |
689 |  |
         /**
690 |  |
          * @param parameterName
691 |  |
          * @param x
692 |  |
          * @throws java.sql.SQLException
693 |  |
          */
694 | 0 |
         public void setInt(String parameterName, int x) throws SQLException {
695 | 0 |
             wrapped.setInt(parameterName, x);
696 | 0 |
             addParam(parameterName, new Integer(x));
697 |  |
         }
698 |  |
699 |  |
         /**
700 |  |
          * @param parameterName
701 |  |
          * @param x
702 |  |
          * @throws java.sql.SQLException
703 |  |
          */
704 | 0 |
         public void setLong(String parameterName, long x) throws SQLException {
705 | 0 |
             wrapped.setLong(parameterName, x);
706 | 0 |
             addParam(parameterName, new Long(x));
707 |  |
         }
708 |  |
709 |  |
         /**
710 |  |
          * @param parameterName
711 |  |
          * @param sqlType
712 |  |
          * @throws java.sql.SQLException
713 |  |
          */
714 | 0 |
         public void setNull(String parameterName, int sqlType) throws SQLException {
715 | 0 |
             wrapped.setNull(parameterName, sqlType);
716 |  |
             //addParam(parameterName, null);
717 |  |
         }
718 |  |
719 |  |
         /**
720 |  |
          * @param parameterName
721 |  |
          * @param sqlType
722 |  |
          * @param typeName
723 |  |
          * @throws java.sql.SQLException
724 |  |
          */
725 | 0 |
         public void setNull(String parameterName, int sqlType, String typeName)
726 |  |
                 throws SQLException {
727 | 0 |
             wrapped.setNull(parameterName, sqlType, typeName);
728 |  |
             //addParam(parameterName, null);
729 |  |
         }
730 |  |
731 |  |
         /**
732 |  |
          * @param parameterName
733 |  |
          * @param x
734 |  |
          * @throws java.sql.SQLException
735 |  |
          */
736 | 0 |
         public void setObject(String parameterName, Object x) throws SQLException {
737 | 0 |
             wrapped.setObject(parameterName, x);
738 | 0 |
             addParam(parameterName, x);
739 |  |
         }
740 |  |
741 |  |
         /**
742 |  |
          * @param parameterName
743 |  |
          * @param x
744 |  |
          * @param targetSqlType
745 |  |
          * @throws java.sql.SQLException
746 |  |
          */
747 | 0 |
         public void setObject(String parameterName, Object x, int targetSqlType)
748 |  |
                 throws SQLException {
749 | 0 |
             wrapped.setObject(parameterName, x, targetSqlType);
750 | 0 |
             addParam(parameterName, x);
751 |  |
         }
752 |  |
753 |  |
         /**
754 |  |
          * @param parameterName
755 |  |
          * @param x
756 |  |
          * @param targetSqlType
757 |  |
          * @param scale
758 |  |
          * @throws java.sql.SQLException
759 |  |
          */
760 | 0 |
         public void setObject(String parameterName, Object x, int targetSqlType,
761 |  |
                 int scale) throws SQLException {
762 | 0 |
             wrapped.setObject(parameterName, x, targetSqlType, scale);
763 | 0 |
             addParam(parameterName, x);
764 |  |
         }
765 |  |
766 |  |
         /**
767 |  |
          * @param parameterName
768 |  |
          * @param x
769 |  |
          * @throws java.sql.SQLException
770 |  |
          */
771 | 0 |
         public void setShort(String parameterName, short x) throws SQLException {
772 | 0 |
             wrapped.setShort(parameterName, x);
773 | 0 |
             addParam(parameterName, new Short(x));
774 |  |
         }
775 |  |
776 |  |
         /**
777 |  |
          * @param parameterName
778 |  |
          * @param x
779 |  |
          * @throws java.sql.SQLException
780 |  |
          */
781 | 0 |
         public void setString(String parameterName, String x) throws SQLException {
782 | 0 |
             wrapped.setString(parameterName, x);
783 | 0 |
             addParam(parameterName, x);
784 |  |
         }
785 |  |
786 |  |
         /**
787 |  |
          * @param parameterName
788 |  |
          * @param x
789 |  |
          * @throws java.sql.SQLException
790 |  |
          */
791 | 0 |
         public void setTime(String parameterName, Time x) throws SQLException {
792 | 0 |
             wrapped.setTime(parameterName, x);
793 | 0 |
             addParam(parameterName, x);
794 |  |
         }
795 |  |
796 |  |
         /**
797 |  |
          * @param parameterName
798 |  |
          * @param x
799 |  |
          * @param cal
800 |  |
          * @throws java.sql.SQLException
801 |  |
          */
802 | 0 |
         public void setTime(String parameterName, Time x, Calendar cal)
803 |  |
                 throws SQLException {
804 | 0 |
             wrapped.setTime(parameterName, x, cal);
805 | 0 |
             addParam(parameterName, x);
806 |  |
         }
807 |  |
808 |  |
         /**
809 |  |
          * @param parameterName
810 |  |
          * @param x
811 |  |
          * @throws java.sql.SQLException
812 |  |
          */
813 | 0 |
         public void setTimestamp(String parameterName, Timestamp x)
814 |  |
                 throws SQLException {
815 | 0 |
             wrapped.setTimestamp(parameterName, x);
816 | 0 |
             addParam(parameterName, x);
817 |  |
         }
818 |  |
819 |  |
         /**
820 |  |
          * @param parameterName
821 |  |
          * @param x
822 |  |
          * @param cal
823 |  |
          * @throws java.sql.SQLException
824 |  |
          */
825 | 0 |
         public void setTimestamp(String parameterName, Timestamp x, Calendar cal)
826 |  |
                 throws SQLException {
827 | 0 |
             wrapped.setTimestamp(parameterName, x, cal);
828 | 0 |
             addParam(parameterName, x);
829 |  |
         }
830 |  |
831 |  |
         /**
832 |  |
          * @param parameterName
833 |  |
          * @param val
834 |  |
          * @throws java.sql.SQLException
835 |  |
          */
836 | 0 |
         public void setURL(String parameterName, URL x) throws SQLException {
837 | 0 |
             wrapped.setURL(parameterName, x);
838 | 0 |
             addParam(parameterName, x);
839 |  |
         }
840 |  |
841 |  |
         /**
842 |  |
          * @return @throws
843 |  |
          *         java.sql.SQLException
844 |  |
          */
845 | 0 |
         public boolean wasNull() throws SQLException {
846 | 0 |
             return wrapped.wasNull();
847 |  |
         }
848 |  |
849 |  |
     }