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: | 1,289 |  | Methods: | 140
| NCLOC: | 459 |  | 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
ResultSetWrapper.java | - | 0% | 0% | 0% |

1 |  |
     /*
2 |  |
      * Joey and its relative products are published under the terms
3 |  |
      * of the Apache Software License.
4 |  |
      */
5 |  |
     package org.asyrinx.brownie.jdbc.wrapper;
6 |  |
7 |  |
     import java.io.InputStream;
8 |  |
     import java.io.Reader;
9 |  |
     import java.math.BigDecimal;
10 |  |
     import java.net.URL;
11 |  |
     import java.sql.Array;
12 |  |
     import java.sql.Blob;
13 |  |
     import java.sql.Clob;
14 |  |
     import java.sql.Date;
15 |  |
     import java.sql.Ref;
16 |  |
     import java.sql.ResultSet;
17 |  |
     import java.sql.ResultSetMetaData;
18 |  |
     import java.sql.SQLException;
19 |  |
     import java.sql.SQLWarning;
20 |  |
     import java.sql.Statement;
21 |  |
     import java.sql.Time;
22 |  |
     import java.sql.Timestamp;
23 |  |
     import java.util.Calendar;
24 |  |
     import java.util.Map;
25 |  |
26 |  |
     import org.asyrinx.brownie.core.util.Wrapper;
27 |  |
28 |  |
     /**
29 |  |
      * @author Akima
30 |  |
      */
31 |  |
     public class ResultSetWrapper extends Wrapper implements ResultSet {
32 |  |
33 |  |
         /**
34 |  |
          * Constructor for ResultSetWrapper.
35 |  |
          */
36 | 0 |
         public ResultSetWrapper(ResultSet impl) {
37 | 0 |
             super(impl);
38 | 0 |
             this.impl = impl;
39 |  |
         }
40 |  |
41 |  |
         protected final ResultSet impl;
42 |  |
43 |  |
         /**
44 |  |
          * @param row
45 |  |
          * @return @throws
46 |  |
          *         java.sql.SQLException
47 |  |
          */
48 | 0 |
         public boolean absolute(int row) throws SQLException {
49 | 0 |
             return impl.absolute(row);
50 |  |
         }
51 |  |
52 |  |
         /**
53 |  |
          * @throws java.sql.SQLException
54 |  |
          */
55 | 0 |
         public void afterLast() throws SQLException {
56 | 0 |
             impl.afterLast();
57 |  |
         }
58 |  |
59 |  |
         /**
60 |  |
          * @throws java.sql.SQLException
61 |  |
          */
62 | 0 |
         public void beforeFirst() throws SQLException {
63 | 0 |
             impl.beforeFirst();
64 |  |
         }
65 |  |
66 |  |
         /**
67 |  |
          * @throws java.sql.SQLException
68 |  |
          */
69 | 0 |
         public void cancelRowUpdates() throws SQLException {
70 | 0 |
             impl.cancelRowUpdates();
71 |  |
         }
72 |  |
73 |  |
         /**
74 |  |
          * @throws java.sql.SQLException
75 |  |
          */
76 | 0 |
         public void clearWarnings() throws SQLException {
77 | 0 |
             impl.clearWarnings();
78 |  |
         }
79 |  |
80 |  |
         /**
81 |  |
          * @throws java.sql.SQLException
82 |  |
          */
83 | 0 |
         public void close() throws SQLException {
84 | 0 |
             impl.close();
85 |  |
         }
86 |  |
87 |  |
         /**
88 |  |
          * @throws java.sql.SQLException
89 |  |
          */
90 | 0 |
         public void deleteRow() throws SQLException {
91 | 0 |
             impl.deleteRow();
92 |  |
         }
93 |  |
94 |  |
         /**
95 |  |
          * @param columnName
96 |  |
          * @return @throws
97 |  |
          *         java.sql.SQLException
98 |  |
          */
99 | 0 |
         public int findColumn(String columnName) throws SQLException {
100 | 0 |
             return impl.findColumn(columnName);
101 |  |
         }
102 |  |
103 |  |
         /**
104 |  |
          * @return @throws
105 |  |
          *         java.sql.SQLException
106 |  |
          */
107 | 0 |
         public boolean first() throws SQLException {
108 | 0 |
             return impl.first();
109 |  |
         }
110 |  |
111 |  |
         /**
112 |  |
          * @param i
113 |  |
          * @return @throws
114 |  |
          *         java.sql.SQLException
115 |  |
          */
116 | 0 |
         public Array getArray(int i) throws SQLException {
117 | 0 |
             return impl.getArray(i);
118 |  |
         }
119 |  |
120 |  |
         /**
121 |  |
          * @param colName
122 |  |
          * @return @throws
123 |  |
          *         java.sql.SQLException
124 |  |
          */
125 | 0 |
         public Array getArray(String colName) throws SQLException {
126 | 0 |
             return impl.getArray(colName);
127 |  |
         }
128 |  |
129 |  |
         /**
130 |  |
          * @param columnIndex
131 |  |
          * @return @throws
132 |  |
          *         java.sql.SQLException
133 |  |
          */
134 | 0 |
         public InputStream getAsciiStream(int columnIndex) throws SQLException {
135 | 0 |
             return impl.getAsciiStream(columnIndex);
136 |  |
         }
137 |  |
138 |  |
         /**
139 |  |
          * @param columnName
140 |  |
          * @return @throws
141 |  |
          *         java.sql.SQLException
142 |  |
          */
143 | 0 |
         public InputStream getAsciiStream(String columnName) throws SQLException {
144 | 0 |
             return impl.getAsciiStream(columnName);
145 |  |
         }
146 |  |
147 |  |
         /**
148 |  |
          * @param columnIndex
149 |  |
          * @return @throws
150 |  |
          *         java.sql.SQLException
151 |  |
          */
152 | 0 |
         public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
153 | 0 |
             return impl.getBigDecimal(columnIndex);
154 |  |
         }
155 |  |
156 |  |
         /**
157 |  |
          * @param columnIndex
158 |  |
          * @param scale
159 |  |
          * @return @throws
160 |  |
          *         java.sql.SQLException
161 |  |
          * @deprecated
162 |  |
          */
163 | 0 |
         public BigDecimal getBigDecimal(int columnIndex, int scale)
164 |  |
                 throws SQLException {
165 |  |
             //return impl.getBigDecimal(columnIndex, scale);
166 | 0 |
             return null;
167 |  |
         }
168 |  |
169 |  |
         /**
170 |  |
          * @param columnName
171 |  |
          * @return @throws
172 |  |
          *         java.sql.SQLException
173 |  |
          */
174 | 0 |
         public BigDecimal getBigDecimal(String columnName) throws SQLException {
175 | 0 |
             return impl.getBigDecimal(columnName);
176 |  |
         }
177 |  |
178 |  |
         /**
179 |  |
          * @param columnName
180 |  |
          * @param scale
181 |  |
          * @return @throws
182 |  |
          *         java.sql.SQLException
183 |  |
          * @deprecated
184 |  |
          */
185 | 0 |
         public BigDecimal getBigDecimal(String columnName, int scale)
186 |  |
                 throws SQLException {
187 | 0 |
             return null;
188 |  |
             //return impl.getBigDecimal(columnName, scale);
189 |  |
         }
190 |  |
191 |  |
         /**
192 |  |
          * @param columnIndex
193 |  |
          * @return @throws
194 |  |
          *         java.sql.SQLException
195 |  |
          */
196 | 0 |
         public InputStream getBinaryStream(int columnIndex) throws SQLException {
197 | 0 |
             return impl.getBinaryStream(columnIndex);
198 |  |
         }
199 |  |
200 |  |
         /**
201 |  |
          * @param columnName
202 |  |
          * @return @throws
203 |  |
          *         java.sql.SQLException
204 |  |
          */
205 | 0 |
         public InputStream getBinaryStream(String columnName) throws SQLException {
206 | 0 |
             return impl.getBinaryStream(columnName);
207 |  |
         }
208 |  |
209 |  |
         /**
210 |  |
          * @param i
211 |  |
          * @return @throws
212 |  |
          *         java.sql.SQLException
213 |  |
          */
214 | 0 |
         public Blob getBlob(int i) throws SQLException {
215 | 0 |
             return impl.getBlob(i);
216 |  |
         }
217 |  |
218 |  |
         /**
219 |  |
          * @param colName
220 |  |
          * @return @throws
221 |  |
          *         java.sql.SQLException
222 |  |
          */
223 | 0 |
         public Blob getBlob(String colName) throws SQLException {
224 | 0 |
             return impl.getBlob(colName);
225 |  |
         }
226 |  |
227 |  |
         /**
228 |  |
          * @param columnIndex
229 |  |
          * @return @throws
230 |  |
          *         java.sql.SQLException
231 |  |
          */
232 | 0 |
         public boolean getBoolean(int columnIndex) throws SQLException {
233 | 0 |
             return impl.getBoolean(columnIndex);
234 |  |
         }
235 |  |
236 |  |
         /**
237 |  |
          * @param columnName
238 |  |
          * @return @throws
239 |  |
          *         java.sql.SQLException
240 |  |
          */
241 | 0 |
         public boolean getBoolean(String columnName) throws SQLException {
242 | 0 |
             return impl.getBoolean(columnName);
243 |  |
         }
244 |  |
245 |  |
         /**
246 |  |
          * @param columnIndex
247 |  |
          * @return @throws
248 |  |
          *         java.sql.SQLException
249 |  |
          */
250 | 0 |
         public byte getByte(int columnIndex) throws SQLException {
251 | 0 |
             return impl.getByte(columnIndex);
252 |  |
         }
253 |  |
254 |  |
         /**
255 |  |
          * @param columnName
256 |  |
          * @return @throws
257 |  |
          *         java.sql.SQLException
258 |  |
          */
259 | 0 |
         public byte getByte(String columnName) throws SQLException {
260 | 0 |
             return impl.getByte(columnName);
261 |  |
         }
262 |  |
263 |  |
         /**
264 |  |
          * @param columnIndex
265 |  |
          * @return @throws
266 |  |
          *         java.sql.SQLException
267 |  |
          */
268 | 0 |
         public byte[] getBytes(int columnIndex) throws SQLException {
269 | 0 |
             return impl.getBytes(columnIndex);
270 |  |
         }
271 |  |
272 |  |
         /**
273 |  |
          * @param columnName
274 |  |
          * @return @throws
275 |  |
          *         java.sql.SQLException
276 |  |
          */
277 | 0 |
         public byte[] getBytes(String columnName) throws SQLException {
278 | 0 |
             return impl.getBytes(columnName);
279 |  |
         }
280 |  |
281 |  |
         /**
282 |  |
          * @param columnIndex
283 |  |
          * @return @throws
284 |  |
          *         java.sql.SQLException
285 |  |
          */
286 | 0 |
         public Reader getCharacterStream(int columnIndex) throws SQLException {
287 | 0 |
             return impl.getCharacterStream(columnIndex);
288 |  |
         }
289 |  |
290 |  |
         /**
291 |  |
          * @param columnName
292 |  |
          * @return @throws
293 |  |
          *         java.sql.SQLException
294 |  |
          */
295 | 0 |
         public Reader getCharacterStream(String columnName) throws SQLException {
296 | 0 |
             return impl.getCharacterStream(columnName);
297 |  |
         }
298 |  |
299 |  |
         /**
300 |  |
          * @param i
301 |  |
          * @return @throws
302 |  |
          *         java.sql.SQLException
303 |  |
          */
304 | 0 |
         public Clob getClob(int i) throws SQLException {
305 | 0 |
             return impl.getClob(i);
306 |  |
         }
307 |  |
308 |  |
         /**
309 |  |
          * @param colName
310 |  |
          * @return @throws
311 |  |
          *         java.sql.SQLException
312 |  |
          */
313 | 0 |
         public Clob getClob(String colName) throws SQLException {
314 | 0 |
             return impl.getClob(colName);
315 |  |
         }
316 |  |
317 |  |
         /**
318 |  |
          * @return @throws
319 |  |
          *         java.sql.SQLException
320 |  |
          */
321 | 0 |
         public int getConcurrency() throws SQLException {
322 | 0 |
             return impl.getConcurrency();
323 |  |
         }
324 |  |
325 |  |
         /**
326 |  |
          * @return @throws
327 |  |
          *         java.sql.SQLException
328 |  |
          */
329 | 0 |
         public String getCursorName() throws SQLException {
330 | 0 |
             return impl.getCursorName();
331 |  |
         }
332 |  |
333 |  |
         /**
334 |  |
          * @param columnIndex
335 |  |
          * @return @throws
336 |  |
          *         java.sql.SQLException
337 |  |
          */
338 | 0 |
         public Date getDate(int columnIndex) throws SQLException {
339 | 0 |
             return impl.getDate(columnIndex);
340 |  |
         }
341 |  |
342 |  |
         /**
343 |  |
          * @param columnIndex
344 |  |
          * @param cal
345 |  |
          * @return @throws
346 |  |
          *         java.sql.SQLException
347 |  |
          */
348 | 0 |
         public Date getDate(int columnIndex, Calendar cal) throws SQLException {
349 | 0 |
             return impl.getDate(columnIndex, cal);
350 |  |
         }
351 |  |
352 |  |
         /**
353 |  |
          * @param columnName
354 |  |
          * @return @throws
355 |  |
          *         java.sql.SQLException
356 |  |
          */
357 | 0 |
         public Date getDate(String columnName) throws SQLException {
358 | 0 |
             return impl.getDate(columnName);
359 |  |
         }
360 |  |
361 |  |
         /**
362 |  |
          * @param columnName
363 |  |
          * @param cal
364 |  |
          * @return @throws
365 |  |
          *         java.sql.SQLException
366 |  |
          */
367 | 0 |
         public Date getDate(String columnName, Calendar cal) throws SQLException {
368 | 0 |
             return impl.getDate(columnName, cal);
369 |  |
         }
370 |  |
371 |  |
         /**
372 |  |
          * @param columnIndex
373 |  |
          * @return @throws
374 |  |
          *         java.sql.SQLException
375 |  |
          */
376 | 0 |
         public double getDouble(int columnIndex) throws SQLException {
377 | 0 |
             return impl.getDouble(columnIndex);
378 |  |
         }
379 |  |
380 |  |
         /**
381 |  |
          * @param columnName
382 |  |
          * @return @throws
383 |  |
          *         java.sql.SQLException
384 |  |
          */
385 | 0 |
         public double getDouble(String columnName) throws SQLException {
386 | 0 |
             return impl.getDouble(columnName);
387 |  |
         }
388 |  |
389 |  |
         /**
390 |  |
          * @return @throws
391 |  |
          *         java.sql.SQLException
392 |  |
          */
393 | 0 |
         public int getFetchDirection() throws SQLException {
394 | 0 |
             return impl.getFetchDirection();
395 |  |
         }
396 |  |
397 |  |
         /**
398 |  |
          * @return @throws
399 |  |
          *         java.sql.SQLException
400 |  |
          */
401 | 0 |
         public int getFetchSize() throws SQLException {
402 | 0 |
             return impl.getFetchSize();
403 |  |
         }
404 |  |
405 |  |
         /**
406 |  |
          * @param columnIndex
407 |  |
          * @return @throws
408 |  |
          *         java.sql.SQLException
409 |  |
          */
410 | 0 |
         public float getFloat(int columnIndex) throws SQLException {
411 | 0 |
             return impl.getFloat(columnIndex);
412 |  |
         }
413 |  |
414 |  |
         /**
415 |  |
          * @param columnName
416 |  |
          * @return @throws
417 |  |
          *         java.sql.SQLException
418 |  |
          */
419 | 0 |
         public float getFloat(String columnName) throws SQLException {
420 | 0 |
             return impl.getFloat(columnName);
421 |  |
         }
422 |  |
423 |  |
         /**
424 |  |
          * @param columnIndex
425 |  |
          * @return @throws
426 |  |
          *         java.sql.SQLException
427 |  |
          */
428 | 0 |
         public int getInt(int columnIndex) throws SQLException {
429 | 0 |
             return impl.getInt(columnIndex);
430 |  |
         }
431 |  |
432 |  |
         /**
433 |  |
          * @param columnName
434 |  |
          * @return @throws
435 |  |
          *         java.sql.SQLException
436 |  |
          */
437 | 0 |
         public int getInt(String columnName) throws SQLException {
438 | 0 |
             return impl.getInt(columnName);
439 |  |
         }
440 |  |
441 |  |
         /**
442 |  |
          * @param columnIndex
443 |  |
          * @return @throws
444 |  |
          *         java.sql.SQLException
445 |  |
          */
446 | 0 |
         public long getLong(int columnIndex) throws SQLException {
447 | 0 |
             return impl.getLong(columnIndex);
448 |  |
         }
449 |  |
450 |  |
         /**
451 |  |
          * @param columnName
452 |  |
          * @return @throws
453 |  |
          *         java.sql.SQLException
454 |  |
          */
455 | 0 |
         public long getLong(String columnName) throws SQLException {
456 | 0 |
             return impl.getLong(columnName);
457 |  |
         }
458 |  |
459 |  |
         /**
460 |  |
          * @return @throws
461 |  |
          *         java.sql.SQLException
462 |  |
          */
463 | 0 |
         public ResultSetMetaData getMetaData() throws SQLException {
464 | 0 |
             return impl.getMetaData();
465 |  |
         }
466 |  |
467 |  |
         /**
468 |  |
          * @param columnIndex
469 |  |
          * @return @throws
470 |  |
          *         java.sql.SQLException
471 |  |
          */
472 | 0 |
         public Object getObject(int columnIndex) throws SQLException {
473 | 0 |
             return impl.getObject(columnIndex);
474 |  |
         }
475 |  |
476 |  |
         /**
477 |  |
          * @param i
478 |  |
          * @param map
479 |  |
          * @return @throws
480 |  |
          *         java.sql.SQLException
481 |  |
          */
482 | 0 |
         public Object getObject(int i, Map map) throws SQLException {
483 | 0 |
             return impl.getObject(i, map);
484 |  |
         }
485 |  |
486 |  |
         /**
487 |  |
          * @param columnName
488 |  |
          * @return @throws
489 |  |
          *         java.sql.SQLException
490 |  |
          */
491 | 0 |
         public Object getObject(String columnName) throws SQLException {
492 | 0 |
             return impl.getObject(columnName);
493 |  |
         }
494 |  |
495 |  |
         /**
496 |  |
          * @param colName
497 |  |
          * @param map
498 |  |
          * @return @throws
499 |  |
          *         java.sql.SQLException
500 |  |
          */
501 | 0 |
         public Object getObject(String colName, Map map) throws SQLException {
502 | 0 |
             return impl.getObject(colName, map);
503 |  |
         }
504 |  |
505 |  |
         /**
506 |  |
          * @param i
507 |  |
          * @return @throws
508 |  |
          *         java.sql.SQLException
509 |  |
          */
510 | 0 |
         public Ref getRef(int i) throws SQLException {
511 | 0 |
             return impl.getRef(i);
512 |  |
         }
513 |  |
514 |  |
         /**
515 |  |
          * @param colName
516 |  |
          * @return @throws
517 |  |
          *         java.sql.SQLException
518 |  |
          */
519 | 0 |
         public Ref getRef(String colName) throws SQLException {
520 | 0 |
             return impl.getRef(colName);
521 |  |
         }
522 |  |
523 |  |
         /**
524 |  |
          * @return @throws
525 |  |
          *         java.sql.SQLException
526 |  |
          */
527 | 0 |
         public int getRow() throws SQLException {
528 | 0 |
             return impl.getRow();
529 |  |
         }
530 |  |
531 |  |
         /**
532 |  |
          * @param columnIndex
533 |  |
          * @return @throws
534 |  |
          *         java.sql.SQLException
535 |  |
          */
536 | 0 |
         public short getShort(int columnIndex) throws SQLException {
537 | 0 |
             return impl.getShort(columnIndex);
538 |  |
         }
539 |  |
540 |  |
         /**
541 |  |
          * @param columnName
542 |  |
          * @return @throws
543 |  |
          *         java.sql.SQLException
544 |  |
          */
545 | 0 |
         public short getShort(String columnName) throws SQLException {
546 | 0 |
             return impl.getShort(columnName);
547 |  |
         }
548 |  |
549 |  |
         /**
550 |  |
          * @return @throws
551 |  |
          *         java.sql.SQLException
552 |  |
          */
553 | 0 |
         public Statement getStatement() throws SQLException {
554 | 0 |
             return impl.getStatement();
555 |  |
         }
556 |  |
557 |  |
         /**
558 |  |
          * @param columnIndex
559 |  |
          * @return @throws
560 |  |
          *         java.sql.SQLException
561 |  |
          */
562 | 0 |
         public String getString(int columnIndex) throws SQLException {
563 | 0 |
             return impl.getString(columnIndex);
564 |  |
         }
565 |  |
566 |  |
         /**
567 |  |
          * @param columnName
568 |  |
          * @return @throws
569 |  |
          *         java.sql.SQLException
570 |  |
          */
571 | 0 |
         public String getString(String columnName) throws SQLException {
572 | 0 |
             return impl.getString(columnName);
573 |  |
         }
574 |  |
575 |  |
         /**
576 |  |
          * @param columnIndex
577 |  |
          * @return @throws
578 |  |
          *         java.sql.SQLException
579 |  |
          */
580 | 0 |
         public Time getTime(int columnIndex) throws SQLException {
581 | 0 |
             return impl.getTime(columnIndex);
582 |  |
         }
583 |  |
584 |  |
         /**
585 |  |
          * @param columnIndex
586 |  |
          * @param cal
587 |  |
          * @return @throws
588 |  |
          *         java.sql.SQLException
589 |  |
          */
590 | 0 |
         public Time getTime(int columnIndex, Calendar cal) throws SQLException {
591 | 0 |
             return impl.getTime(columnIndex, cal);
592 |  |
         }
593 |  |
594 |  |
         /**
595 |  |
          * @param columnName
596 |  |
          * @return @throws
597 |  |
          *         java.sql.SQLException
598 |  |
          */
599 | 0 |
         public Time getTime(String columnName) throws SQLException {
600 | 0 |
             return impl.getTime(columnName);
601 |  |
         }
602 |  |
603 |  |
         /**
604 |  |
          * @param columnName
605 |  |
          * @param cal
606 |  |
          * @return @throws
607 |  |
          *         java.sql.SQLException
608 |  |
          */
609 | 0 |
         public Time getTime(String columnName, Calendar cal) throws SQLException {
610 | 0 |
             return impl.getTime(columnName, cal);
611 |  |
         }
612 |  |
613 |  |
         /**
614 |  |
          * @param columnIndex
615 |  |
          * @return @throws
616 |  |
          *         java.sql.SQLException
617 |  |
          */
618 | 0 |
         public Timestamp getTimestamp(int columnIndex) throws SQLException {
619 | 0 |
             return impl.getTimestamp(columnIndex);
620 |  |
         }
621 |  |
622 |  |
         /**
623 |  |
          * @param columnIndex
624 |  |
          * @param cal
625 |  |
          * @return @throws
626 |  |
          *         java.sql.SQLException
627 |  |
          */
628 | 0 |
         public Timestamp getTimestamp(int columnIndex, Calendar cal)
629 |  |
                 throws SQLException {
630 | 0 |
             return impl.getTimestamp(columnIndex, cal);
631 |  |
         }
632 |  |
633 |  |
         /**
634 |  |
          * @param columnName
635 |  |
          * @return @throws
636 |  |
          *         java.sql.SQLException
637 |  |
          */
638 | 0 |
         public Timestamp getTimestamp(String columnName) throws SQLException {
639 | 0 |
             return impl.getTimestamp(columnName);
640 |  |
         }
641 |  |
642 |  |
         /**
643 |  |
          * @param columnName
644 |  |
          * @param cal
645 |  |
          * @return @throws
646 |  |
          *         java.sql.SQLException
647 |  |
          */
648 | 0 |
         public Timestamp getTimestamp(String columnName, Calendar cal)
649 |  |
                 throws SQLException {
650 | 0 |
             return impl.getTimestamp(columnName, cal);
651 |  |
         }
652 |  |
653 |  |
         /**
654 |  |
          * @return @throws
655 |  |
          *         java.sql.SQLException
656 |  |
          */
657 | 0 |
         public int getType() throws SQLException {
658 | 0 |
             return impl.getType();
659 |  |
         }
660 |  |
661 |  |
         /**
662 |  |
          * @param columnIndex
663 |  |
          * @return @throws
664 |  |
          *         java.sql.SQLException
665 |  |
          * @deprecated
666 |  |
          */
667 | 0 |
         public InputStream getUnicodeStream(int columnIndex) throws SQLException {
668 |  |
             //return impl.getUnicodeStream(columnIndex);
669 | 0 |
             return null;
670 |  |
         }
671 |  |
672 |  |
         /**
673 |  |
          * @param columnName
674 |  |
          * @return @throws
675 |  |
          *         java.sql.SQLException
676 |  |
          * @deprecated
677 |  |
          */
678 | 0 |
         public InputStream getUnicodeStream(String columnName) throws SQLException {
679 |  |
             //return impl.getUnicodeStream(columnName);
680 | 0 |
             return null;
681 |  |
         }
682 |  |
683 |  |
         /**
684 |  |
          * @param columnIndex
685 |  |
          * @return @throws
686 |  |
          *         java.sql.SQLException
687 |  |
          */
688 | 0 |
         public URL getURL(int columnIndex) throws SQLException {
689 | 0 |
             return impl.getURL(columnIndex);
690 |  |
         }
691 |  |
692 |  |
         /**
693 |  |
          * @param columnName
694 |  |
          * @return @throws
695 |  |
          *         java.sql.SQLException
696 |  |
          */
697 | 0 |
         public URL getURL(String columnName) throws SQLException {
698 | 0 |
             return impl.getURL(columnName);
699 |  |
         }
700 |  |
701 |  |
         /**
702 |  |
          * @return @throws
703 |  |
          *         java.sql.SQLException
704 |  |
          */
705 | 0 |
         public SQLWarning getWarnings() throws SQLException {
706 | 0 |
             return impl.getWarnings();
707 |  |
         }
708 |  |
709 |  |
         /**
710 |  |
          * @throws java.sql.SQLException
711 |  |
          */
712 | 0 |
         public void insertRow() throws SQLException {
713 | 0 |
             impl.insertRow();
714 |  |
         }
715 |  |
716 |  |
         /**
717 |  |
          * @return @throws
718 |  |
          *         java.sql.SQLException
719 |  |
          */
720 | 0 |
         public boolean isAfterLast() throws SQLException {
721 | 0 |
             return impl.isAfterLast();
722 |  |
         }
723 |  |
724 |  |
         /**
725 |  |
          * @return @throws
726 |  |
          *         java.sql.SQLException
727 |  |
          */
728 | 0 |
         public boolean isBeforeFirst() throws SQLException {
729 | 0 |
             return impl.isBeforeFirst();
730 |  |
         }
731 |  |
732 |  |
         /**
733 |  |
          * @return @throws
734 |  |
          *         java.sql.SQLException
735 |  |
          */
736 | 0 |
         public boolean isFirst() throws SQLException {
737 | 0 |
             return impl.isFirst();
738 |  |
         }
739 |  |
740 |  |
         /**
741 |  |
          * @return @throws
742 |  |
          *         java.sql.SQLException
743 |  |
          */
744 | 0 |
         public boolean isLast() throws SQLException {
745 | 0 |
             return impl.isLast();
746 |  |
         }
747 |  |
748 |  |
         /**
749 |  |
          * @return @throws
750 |  |
          *         java.sql.SQLException
751 |  |
          */
752 | 0 |
         public boolean last() throws SQLException {
753 | 0 |
             return impl.last();
754 |  |
         }
755 |  |
756 |  |
         /**
757 |  |
          * @throws java.sql.SQLException
758 |  |
          */
759 | 0 |
         public void moveToCurrentRow() throws SQLException {
760 | 0 |
             impl.moveToCurrentRow();
761 |  |
         }
762 |  |
763 |  |
         /**
764 |  |
          * @throws java.sql.SQLException
765 |  |
          */
766 | 0 |
         public void moveToInsertRow() throws SQLException {
767 | 0 |
             impl.moveToInsertRow();
768 |  |
         }
769 |  |
770 |  |
         /**
771 |  |
          * @return @throws
772 |  |
          *         java.sql.SQLException
773 |  |
          */
774 | 0 |
         public boolean next() throws SQLException {
775 | 0 |
             return impl.next();
776 |  |
         }
777 |  |
778 |  |
         /**
779 |  |
          * @return @throws
780 |  |
          *         java.sql.SQLException
781 |  |
          */
782 | 0 |
         public boolean previous() throws SQLException {
783 | 0 |
             return impl.previous();
784 |  |
         }
785 |  |
786 |  |
         /**
787 |  |
          * @throws java.sql.SQLException
788 |  |
          */
789 | 0 |
         public void refreshRow() throws SQLException {
790 | 0 |
             impl.refreshRow();
791 |  |
         }
792 |  |
793 |  |
         /**
794 |  |
          * @param rows
795 |  |
          * @return @throws
796 |  |
          *         java.sql.SQLException
797 |  |
          */
798 | 0 |
         public boolean relative(int rows) throws SQLException {
799 | 0 |
             return impl.relative(rows);
800 |  |
         }
801 |  |
802 |  |
         /**
803 |  |
          * @return @throws
804 |  |
          *         java.sql.SQLException
805 |  |
          */
806 | 0 |
         public boolean rowDeleted() throws SQLException {
807 | 0 |
             return impl.rowDeleted();
808 |  |
         }
809 |  |
810 |  |
         /**
811 |  |
          * @return @throws
812 |  |
          *         java.sql.SQLException
813 |  |
          */
814 | 0 |
         public boolean rowInserted() throws SQLException {
815 | 0 |
             return impl.rowInserted();
816 |  |
         }
817 |  |
818 |  |
         /**
819 |  |
          * @return @throws
820 |  |
          *         java.sql.SQLException
821 |  |
          */
822 | 0 |
         public boolean rowUpdated() throws SQLException {
823 | 0 |
             return impl.rowUpdated();
824 |  |
         }
825 |  |
826 |  |
         /**
827 |  |
          * @param direction
828 |  |
          * @throws java.sql.SQLException
829 |  |
          */
830 | 0 |
         public void setFetchDirection(int direction) throws SQLException {
831 | 0 |
             impl.setFetchDirection(direction);
832 |  |
         }
833 |  |
834 |  |
         /**
835 |  |
          * @param rows
836 |  |
          * @throws java.sql.SQLException
837 |  |
          */
838 | 0 |
         public void setFetchSize(int rows) throws SQLException {
839 | 0 |
             impl.setFetchSize(rows);
840 |  |
         }
841 |  |
842 |  |
         /**
843 |  |
          * @param columnIndex
844 |  |
          * @param x
845 |  |
          * @throws java.sql.SQLException
846 |  |
          */
847 | 0 |
         public void updateArray(int columnIndex, Array x) throws SQLException {
848 | 0 |
             impl.updateArray(columnIndex, x);
849 |  |
         }
850 |  |
851 |  |
         /**
852 |  |
          * @param columnName
853 |  |
          * @param x
854 |  |
          * @throws java.sql.SQLException
855 |  |
          */
856 | 0 |
         public void updateArray(String columnName, Array x) throws SQLException {
857 | 0 |
             impl.updateArray(columnName, x);
858 |  |
         }
859 |  |
860 |  |
         /**
861 |  |
          * @param columnIndex
862 |  |
          * @param x
863 |  |
          * @param length
864 |  |
          * @throws java.sql.SQLException
865 |  |
          */
866 | 0 |
         public void updateAsciiStream(int columnIndex, InputStream x, int length)
867 |  |
                 throws SQLException {
868 | 0 |
             impl.updateAsciiStream(columnIndex, x, length);
869 |  |
         }
870 |  |
871 |  |
         /**
872 |  |
          * @param columnName
873 |  |
          * @param x
874 |  |
          * @param length
875 |  |
          * @throws java.sql.SQLException
876 |  |
          */
877 | 0 |
         public void updateAsciiStream(String columnName, InputStream x, int length)
878 |  |
                 throws SQLException {
879 | 0 |
             impl.updateAsciiStream(columnName, x, length);
880 |  |
         }
881 |  |
882 |  |
         /**
883 |  |
          * @param columnIndex
884 |  |
          * @param x
885 |  |
          * @throws java.sql.SQLException
886 |  |
          */
887 | 0 |
         public void updateBigDecimal(int columnIndex, BigDecimal x)
888 |  |
                 throws SQLException {
889 | 0 |
             impl.updateBigDecimal(columnIndex, x);
890 |  |
         }
891 |  |
892 |  |
         /**
893 |  |
          * @param columnName
894 |  |
          * @param x
895 |  |
          * @throws java.sql.SQLException
896 |  |
          */
897 | 0 |
         public void updateBigDecimal(String columnName, BigDecimal x)
898 |  |
                 throws SQLException {
899 | 0 |
             impl.updateBigDecimal(columnName, x);
900 |  |
         }
901 |  |
902 |  |
         /**
903 |  |
          * @param columnIndex
904 |  |
          * @param x
905 |  |
          * @param length
906 |  |
          * @throws java.sql.SQLException
907 |  |
          */
908 | 0 |
         public void updateBinaryStream(int columnIndex, InputStream x, int length)
909 |  |
                 throws SQLException {
910 | 0 |
             impl.updateBinaryStream(columnIndex, x, length);
911 |  |
         }
912 |  |
913 |  |
         /**
914 |  |
          * @param columnName
915 |  |
          * @param x
916 |  |
          * @param length
917 |  |
          * @throws java.sql.SQLException
918 |  |
          */
919 | 0 |
         public void updateBinaryStream(String columnName, InputStream x, int length)
920 |  |
                 throws SQLException {
921 | 0 |
             impl.updateBinaryStream(columnName, x, length);
922 |  |
         }
923 |  |
924 |  |
         /**
925 |  |
          * @param columnIndex
926 |  |
          * @param x
927 |  |
          * @throws java.sql.SQLException
928 |  |
          */
929 | 0 |
         public void updateBlob(int columnIndex, Blob x) throws SQLException {
930 | 0 |
             impl.updateBlob(columnIndex, x);
931 |  |
         }
932 |  |
933 |  |
         /**
934 |  |
          * @param columnName
935 |  |
          * @param x
936 |  |
          * @throws java.sql.SQLException
937 |  |
          */
938 | 0 |
         public void updateBlob(String columnName, Blob x) throws SQLException {
939 | 0 |
             impl.updateBlob(columnName, x);
940 |  |
         }
941 |  |
942 |  |
         /**
943 |  |
          * @param columnIndex
944 |  |
          * @param x
945 |  |
          * @throws java.sql.SQLException
946 |  |
          */
947 | 0 |
         public void updateBoolean(int columnIndex, boolean x) throws SQLException {
948 | 0 |
             impl.updateBoolean(columnIndex, x);
949 |  |
         }
950 |  |
951 |  |
         /**
952 |  |
          * @param columnName
953 |  |
          * @param x
954 |  |
          * @throws java.sql.SQLException
955 |  |
          */
956 | 0 |
         public void updateBoolean(String columnName, boolean x) throws SQLException {
957 | 0 |
             impl.updateBoolean(columnName, x);
958 |  |
         }
959 |  |
960 |  |
         /**
961 |  |
          * @param columnIndex
962 |  |
          * @param x
963 |  |
          * @throws java.sql.SQLException
964 |  |
          */
965 | 0 |
         public void updateByte(int columnIndex, byte x) throws SQLException {
966 | 0 |
             impl.updateByte(columnIndex, x);
967 |  |
         }
968 |  |
969 |  |
         /**
970 |  |
          * @param columnName
971 |  |
          * @param x
972 |  |
          * @throws java.sql.SQLException
973 |  |
          */
974 | 0 |
         public void updateByte(String columnName, byte x) throws SQLException {
975 | 0 |
             impl.updateByte(columnName, x);
976 |  |
         }
977 |  |
978 |  |
         /**
979 |  |
          * @param columnIndex
980 |  |
          * @param x
981 |  |
          * @throws java.sql.SQLException
982 |  |
          */
983 | 0 |
         public void updateBytes(int columnIndex, byte[] x) throws SQLException {
984 | 0 |
             impl.updateBytes(columnIndex, x);
985 |  |
         }
986 |  |
987 |  |
         /**
988 |  |
          * @param columnName
989 |  |
          * @param x
990 |  |
          * @throws java.sql.SQLException
991 |  |
          */
992 | 0 |
         public void updateBytes(String columnName, byte[] x) throws SQLException {
993 | 0 |
             impl.updateBytes(columnName, x);
994 |  |
         }
995 |  |
996 |  |
         /**
997 |  |
          * @param columnIndex
998 |  |
          * @param x
999 |  |
          * @param length
1000 |  |
          * @throws java.sql.SQLException
1001 |  |
          */
1002 | 0 |
         public void updateCharacterStream(int columnIndex, Reader x, int length)
1003 |  |
                 throws SQLException {
1004 | 0 |
             impl.updateCharacterStream(columnIndex, x, length);
1005 |  |
         }
1006 |  |
1007 |  |
         /**
1008 |  |
          * @param columnName
1009 |  |
          * @param reader
1010 |  |
          * @param length
1011 |  |
          * @throws java.sql.SQLException
1012 |  |
          */
1013 | 0 |
         public void updateCharacterStream(String columnName, Reader reader,
1014 |  |
                 int length) throws SQLException {
1015 | 0 |
             impl.updateCharacterStream(columnName, reader, length);
1016 |  |
         }
1017 |  |
1018 |  |
         /**
1019 |  |
          * @param columnIndex
1020 |  |
          * @param x
1021 |  |
          * @throws java.sql.SQLException
1022 |  |
          */
1023 | 0 |
         public void updateClob(int columnIndex, Clob x) throws SQLException {
1024 | 0 |
             impl.updateClob(columnIndex, x);
1025 |  |
         }
1026 |  |
1027 |  |
         /**
1028 |  |
          * @param columnName
1029 |  |
          * @param x
1030 |  |
          * @throws java.sql.SQLException
1031 |  |
          */
1032 | 0 |
         public void updateClob(String columnName, Clob x) throws SQLException {
1033 | 0 |
             impl.updateClob(columnName, x);
1034 |  |
         }
1035 |  |
1036 |  |
         /**
1037 |  |
          * @param columnIndex
1038 |  |
          * @param x
1039 |  |
          * @throws java.sql.SQLException
1040 |  |
          */
1041 | 0 |
         public void updateDate(int columnIndex, Date x) throws SQLException {
1042 | 0 |
             impl.updateDate(columnIndex, x);
1043 |  |
         }
1044 |  |
1045 |  |
         /**
1046 |  |
          * @param columnName
1047 |  |
          * @param x
1048 |  |
          * @throws java.sql.SQLException
1049 |  |
          */
1050 | 0 |
         public void updateDate(String columnName, Date x) throws SQLException {
1051 | 0 |
             impl.updateDate(columnName, x);
1052 |  |
         }
1053 |  |
1054 |  |
         /**
1055 |  |
          * @param columnIndex
1056 |  |
          * @param x
1057 |  |
          * @throws java.sql.SQLException
1058 |  |
          */
1059 | 0 |
         public void updateDouble(int columnIndex, double x) throws SQLException {
1060 | 0 |
             impl.updateDouble(columnIndex, x);
1061 |  |
         }
1062 |  |
1063 |  |
         /**
1064 |  |
          * @param columnName
1065 |  |
          * @param x
1066 |  |
          * @throws java.sql.SQLException
1067 |  |
          */
1068 | 0 |
         public void updateDouble(String columnName, double x) throws SQLException {
1069 | 0 |
             impl.updateDouble(columnName, x);
1070 |  |
         }
1071 |  |
1072 |  |
         /**
1073 |  |
          * @param columnIndex
1074 |  |
          * @param x
1075 |  |
          * @throws java.sql.SQLException
1076 |  |
          */
1077 | 0 |
         public void updateFloat(int columnIndex, float x) throws SQLException {
1078 | 0 |
             impl.updateFloat(columnIndex, x);
1079 |  |
         }
1080 |  |
1081 |  |
         /**
1082 |  |
          * @param columnName
1083 |  |
          * @param x
1084 |  |
          * @throws java.sql.SQLException
1085 |  |
          */
1086 | 0 |
         public void updateFloat(String columnName, float x) throws SQLException {
1087 | 0 |
             impl.updateFloat(columnName, x);
1088 |  |
         }
1089 |  |
1090 |  |
         /**
1091 |  |
          * @param columnIndex
1092 |  |
          * @param x
1093 |  |
          * @throws java.sql.SQLException
1094 |  |
          */
1095 | 0 |
         public void updateInt(int columnIndex, int x) throws SQLException {
1096 | 0 |
             impl.updateInt(columnIndex, x);
1097 |  |
         }
1098 |  |
1099 |  |
         /**
1100 |  |
          * @param columnName
1101 |  |
          * @param x
1102 |  |
          * @throws java.sql.SQLException
1103 |  |
          */
1104 | 0 |
         public void updateInt(String columnName, int x) throws SQLException {
1105 | 0 |
             impl.updateInt(columnName, x);
1106 |  |
         }
1107 |  |
1108 |  |
         /**
1109 |  |
          * @param columnIndex
1110 |  |
          * @param x
1111 |  |
          * @throws java.sql.SQLException
1112 |  |
          */
1113 | 0 |
         public void updateLong(int columnIndex, long x) throws SQLException {
1114 | 0 |
             impl.updateLong(columnIndex, x);
1115 |  |
         }
1116 |  |
1117 |  |
         /**
1118 |  |
          * @param columnName
1119 |  |
          * @param x
1120 |  |
          * @throws java.sql.SQLException
1121 |  |
          */
1122 | 0 |
         public void updateLong(String columnName, long x) throws SQLException {
1123 | 0 |
             impl.updateLong(columnName, x);
1124 |  |
         }
1125 |  |
1126 |  |
         /**
1127 |  |
          * @param columnIndex
1128 |  |
          * @throws java.sql.SQLException
1129 |  |
          */
1130 | 0 |
         public void updateNull(int columnIndex) throws SQLException {
1131 | 0 |
             impl.updateNull(columnIndex);
1132 |  |
         }
1133 |  |
1134 |  |
         /**
1135 |  |
          * @param columnName
1136 |  |
          * @throws java.sql.SQLException
1137 |  |
          */
1138 | 0 |
         public void updateNull(String columnName) throws SQLException {
1139 | 0 |
             impl.updateNull(columnName);
1140 |  |
         }
1141 |  |
1142 |  |
         /**
1143 |  |
          * @param columnIndex
1144 |  |
          * @param x
1145 |  |
          * @throws java.sql.SQLException
1146 |  |
          */
1147 | 0 |
         public void updateObject(int columnIndex, Object x) throws SQLException {
1148 | 0 |
             impl.updateObject(columnIndex, x);
1149 |  |
         }
1150 |  |
1151 |  |
         /**
1152 |  |
          * @param columnIndex
1153 |  |
          * @param x
1154 |  |
          * @param scale
1155 |  |
          * @throws java.sql.SQLException
1156 |  |
          */
1157 | 0 |
         public void updateObject(int columnIndex, Object x, int scale)
1158 |  |
                 throws SQLException {
1159 | 0 |
             impl.updateObject(columnIndex, x, scale);
1160 |  |
         }
1161 |  |
1162 |  |
         /**
1163 |  |
          * @param columnName
1164 |  |
          * @param x
1165 |  |
          * @throws java.sql.SQLException
1166 |  |
          */
1167 | 0 |
         public void updateObject(String columnName, Object x) throws SQLException {
1168 | 0 |
             impl.updateObject(columnName, x);
1169 |  |
         }
1170 |  |
1171 |  |
         /**
1172 |  |
          * @param columnName
1173 |  |
          * @param x
1174 |  |
          * @param scale
1175 |  |
          * @throws java.sql.SQLException
1176 |  |
          */
1177 | 0 |
         public void updateObject(String columnName, Object x, int scale)
1178 |  |
                 throws SQLException {
1179 | 0 |
             impl.updateObject(columnName, x, scale);
1180 |  |
         }
1181 |  |
1182 |  |
         /**
1183 |  |
          * @param columnIndex
1184 |  |
          * @param x
1185 |  |
          * @throws java.sql.SQLException
1186 |  |
          */
1187 | 0 |
         public void updateRef(int columnIndex, Ref x) throws SQLException {
1188 | 0 |
             impl.updateRef(columnIndex, x);
1189 |  |
         }
1190 |  |
1191 |  |
         /**
1192 |  |
          * @param columnName
1193 |  |
          * @param x
1194 |  |
          * @throws java.sql.SQLException
1195 |  |
          */
1196 | 0 |
         public void updateRef(String columnName, Ref x) throws SQLException {
1197 | 0 |
             impl.updateRef(columnName, x);
1198 |  |
         }
1199 |  |
1200 |  |
         /**
1201 |  |
          * @throws java.sql.SQLException
1202 |  |
          */
1203 | 0 |
         public void updateRow() throws SQLException {
1204 | 0 |
             impl.updateRow();
1205 |  |
         }
1206 |  |
1207 |  |
         /**
1208 |  |
          * @param columnIndex
1209 |  |
          * @param x
1210 |  |
          * @throws java.sql.SQLException
1211 |  |
          */
1212 | 0 |
         public void updateShort(int columnIndex, short x) throws SQLException {
1213 | 0 |
             impl.updateShort(columnIndex, x);
1214 |  |
         }
1215 |  |
1216 |  |
         /**
1217 |  |
          * @param columnName
1218 |  |
          * @param x
1219 |  |
          * @throws java.sql.SQLException
1220 |  |
          */
1221 | 0 |
         public void updateShort(String columnName, short x) throws SQLException {
1222 | 0 |
             impl.updateShort(columnName, x);
1223 |  |
         }
1224 |  |
1225 |  |
         /**
1226 |  |
          * @param columnIndex
1227 |  |
          * @param x
1228 |  |
          * @throws java.sql.SQLException
1229 |  |
          */
1230 | 0 |
         public void updateString(int columnIndex, String x) throws SQLException {
1231 | 0 |
             impl.updateString(columnIndex, x);
1232 |  |
         }
1233 |  |
1234 |  |
         /**
1235 |  |
          * @param columnName
1236 |  |
          * @param x
1237 |  |
          * @throws java.sql.SQLException
1238 |  |
          */
1239 | 0 |
         public void updateString(String columnName, String x) throws SQLException {
1240 | 0 |
             impl.updateString(columnName, x);
1241 |  |
         }
1242 |  |
1243 |  |
         /**
1244 |  |
          * @param columnIndex
1245 |  |
          * @param x
1246 |  |
          * @throws java.sql.SQLException
1247 |  |
          */
1248 | 0 |
         public void updateTime(int columnIndex, Time x) throws SQLException {
1249 | 0 |
             impl.updateTime(columnIndex, x);
1250 |  |
         }
1251 |  |
1252 |  |
         /**
1253 |  |
          * @param columnName
1254 |  |
          * @param x
1255 |  |
          * @throws java.sql.SQLException
1256 |  |
          */
1257 | 0 |
         public void updateTime(String columnName, Time x) throws SQLException {
1258 | 0 |
             impl.updateTime(columnName, x);
1259 |  |
         }
1260 |  |
1261 |  |
         /**
1262 |  |
          * @param columnIndex
1263 |  |
          * @param x
1264 |  |
          * @throws java.sql.SQLException
1265 |  |
          */
1266 | 0 |
         public void updateTimestamp(int columnIndex, Timestamp x)
1267 |  |
                 throws SQLException {
1268 | 0 |
             impl.updateTimestamp(columnIndex, x);
1269 |  |
         }
1270 |  |
1271 |  |
         /**
1272 |  |
          * @param columnName
1273 |  |
          * @param x
1274 |  |
          * @throws java.sql.SQLException
1275 |  |
          */
1276 | 0 |
         public void updateTimestamp(String columnName, Timestamp x)
1277 |  |
                 throws SQLException {
1278 | 0 |
             impl.updateTimestamp(columnName, x);
1279 |  |
         }
1280 |  |
1281 |  |
         /**
1282 |  |
          * @return @throws
1283 |  |
          *         java.sql.SQLException
1284 |  |
          */
1285 | 0 |
         public boolean wasNull() throws SQLException {
1286 | 0 |
             return impl.wasNull();
1287 |  |
         }
1288 |  |
1289 |  |
     }