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