001 package com.mockrunner.mock.jdbc;
002
003 import java.io.InputStream;
004 import java.io.Reader;
005 import java.math.BigDecimal;
006 import java.net.URL;
007 import java.sql.Array;
008 import java.sql.Blob;
009 import java.sql.Clob;
010 import java.sql.Date;
011 import java.sql.NClob;
012 import java.sql.Ref;
013 import java.sql.ResultSet;
014 import java.sql.ResultSetMetaData;
015 import java.sql.RowId;
016 import java.sql.SQLException;
017 import java.sql.SQLWarning;
018 import java.sql.SQLXML;
019 import java.sql.Statement;
020 import java.sql.Time;
021 import java.sql.Timestamp;
022 import java.util.Calendar;
023 import java.util.Collections;
024 import java.util.List;
025 import java.util.Map;
026
027 /**
028 * Contains a list of <code>ResultSet</code> objects where the <code>next()</code>
029 * method iterates through all <code>ResultSet</code> objects in the list.
030 * The get-methods and <code>next()</code> can be used. All update-methods
031 * and scroll-methods throw an <code>SQLException</code>.
032 */
033 public class PolyResultSet implements ResultSet
034 {
035 private List resultSets;
036 private int position;
037 private ResultSet current;
038
039 public PolyResultSet(List resultSets)
040 {
041 this.resultSets = resultSets;
042 }
043
044 public List getUnderlyingResultSetList()
045 {
046 return Collections.unmodifiableList(resultSets);
047 }
048
049 public boolean next() throws SQLException
050 {
051 if((current != null) && current.next())
052 {
053 return true;
054 }
055 else
056 {
057 while(position < resultSets.size())
058 {
059 current = (ResultSet)resultSets.get(position++);
060 if(current.next()) return true;
061 }
062 }
063 return false;
064 }
065
066 /**
067 * Does nothing.
068 */
069 public void close() throws SQLException
070 {
071
072 }
073
074 public boolean isClosed() throws SQLException
075 {
076 return false;
077 }
078
079 public boolean wasNull() throws SQLException
080 {
081 return current.wasNull();
082 }
083
084 public String getString(int columnIndex) throws SQLException
085 {
086 return current.getString(columnIndex);
087 }
088
089 public String getNString(int columnIndex) throws SQLException
090 {
091 return current.getNString(columnIndex);
092 }
093
094 public boolean getBoolean(int columnIndex) throws SQLException
095 {
096 return current.getBoolean(columnIndex);
097 }
098
099 public byte getByte(int columnIndex) throws SQLException
100 {
101 return current.getByte(columnIndex);
102 }
103
104 public short getShort(int columnIndex) throws SQLException
105 {
106 return current.getShort(columnIndex);
107 }
108
109 public int getInt(int columnIndex) throws SQLException
110 {
111 return current.getInt(columnIndex);
112 }
113
114 public long getLong(int columnIndex) throws SQLException
115 {
116 return current.getLong(columnIndex);
117 }
118
119 public float getFloat(int columnIndex) throws SQLException
120 {
121 return current.getFloat(columnIndex);
122 }
123
124 public double getDouble(int columnIndex) throws SQLException
125 {
126 return current.getDouble(columnIndex);
127 }
128
129 public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException
130 {
131 return current.getBigDecimal(columnIndex);
132 }
133
134 public BigDecimal getBigDecimal(int columnIndex) throws SQLException
135 {
136 return current.getBigDecimal(columnIndex);
137 }
138
139 public byte[] getBytes(int columnIndex) throws SQLException
140 {
141 return current.getBytes(columnIndex);
142 }
143
144 public Date getDate(int columnIndex) throws SQLException
145 {
146 return current.getDate(columnIndex);
147 }
148
149 public Date getDate(int columnIndex, Calendar cal) throws SQLException
150 {
151 return current.getDate(columnIndex, cal);
152 }
153
154 public Time getTime(int columnIndex) throws SQLException
155 {
156 return current.getTime(columnIndex);
157 }
158
159 public Time getTime(int columnIndex, Calendar cal) throws SQLException
160 {
161 return current.getTime(columnIndex, cal);
162 }
163
164 public Timestamp getTimestamp(int columnIndex) throws SQLException
165 {
166 return current.getTimestamp(columnIndex);
167 }
168
169 public Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException
170 {
171 return current.getTimestamp(columnIndex, cal);
172 }
173
174 public InputStream getAsciiStream(int columnIndex) throws SQLException
175 {
176 return current.getAsciiStream(columnIndex);
177 }
178
179 public InputStream getBinaryStream(int columnIndex) throws SQLException
180 {
181 return current.getBinaryStream(columnIndex);
182 }
183
184 public InputStream getUnicodeStream(int columnIndex) throws SQLException
185 {
186 return current.getUnicodeStream(columnIndex);
187 }
188
189 public Reader getCharacterStream(int columnIndex) throws SQLException
190 {
191 return current.getCharacterStream(columnIndex);
192 }
193
194 public Reader getNCharacterStream(int columnIndex) throws SQLException
195 {
196 return current.getCharacterStream(columnIndex);
197 }
198
199 public Ref getRef(int columnIndex) throws SQLException
200 {
201 return current.getRef(columnIndex);
202 }
203
204 public RowId getRowId(int columnIndex) throws SQLException
205 {
206 return current.getRowId(columnIndex);
207 }
208
209 public Blob getBlob(int columnIndex) throws SQLException
210 {
211 return current.getBlob(columnIndex);
212 }
213
214 public Clob getClob(int columnIndex) throws SQLException
215 {
216 return current.getClob(columnIndex);
217 }
218
219 public NClob getNClob(int columnIndex) throws SQLException
220 {
221 return current.getNClob(columnIndex);
222 }
223
224 public SQLXML getSQLXML(int columnIndex) throws SQLException
225 {
226 return current.getSQLXML(columnIndex);
227 }
228
229 public Array getArray(int columnIndex) throws SQLException
230 {
231 return current.getArray(columnIndex);
232 }
233
234 public URL getURL(int columnIndex) throws SQLException
235 {
236 return current.getURL(columnIndex);
237 }
238
239 public Object getObject(int columnIndex) throws SQLException
240 {
241 return current.getObject(columnIndex);
242 }
243
244 public Object getObject(int columnIndex, Map map) throws SQLException
245 {
246 return current.getObject(columnIndex, map);
247 }
248
249 public String getString(String columnName) throws SQLException
250 {
251 return current.getString(columnName);
252 }
253
254 public String getNString(String columnName) throws SQLException
255 {
256 return current.getString(columnName);
257 }
258
259 public boolean getBoolean(String columnName) throws SQLException
260 {
261 return current.getBoolean(columnName);
262 }
263
264 public byte getByte(String columnName) throws SQLException
265 {
266 return current.getByte(columnName);
267 }
268
269 public short getShort(String columnName) throws SQLException
270 {
271 return current.getShort(columnName);
272 }
273
274 public int getInt(String columnName) throws SQLException
275 {
276 return current.getInt(columnName);
277 }
278
279 public long getLong(String columnName) throws SQLException
280 {
281 return current.getLong(columnName);
282 }
283
284 public float getFloat(String columnName) throws SQLException
285 {
286 return current.getFloat(columnName);
287 }
288
289 public double getDouble(String columnName) throws SQLException
290 {
291 return current.getDouble(columnName);
292 }
293
294 public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException
295 {
296 return current.getBigDecimal(columnName);
297 }
298
299 public BigDecimal getBigDecimal(String columnName) throws SQLException
300 {
301 return current.getBigDecimal(columnName);
302 }
303
304 public byte[] getBytes(String columnName) throws SQLException
305 {
306 return current.getBytes(columnName);
307 }
308
309 public Date getDate(String columnName) throws SQLException
310 {
311 return current.getDate(columnName);
312 }
313
314 public Date getDate(String columnName, Calendar cal) throws SQLException
315 {
316 return current.getDate(columnName, cal);
317 }
318
319 public Time getTime(String columnName) throws SQLException
320 {
321 return current.getTime(columnName);
322 }
323
324 public Time getTime(String columnName, Calendar cal) throws SQLException
325 {
326 return current.getTime(columnName, cal);
327 }
328
329 public Timestamp getTimestamp(String columnName) throws SQLException
330 {
331 return current.getTimestamp(columnName);
332 }
333
334 public Timestamp getTimestamp(String columnName, Calendar cal) throws SQLException
335 {
336 return current.getTimestamp(columnName, cal);
337 }
338
339 public InputStream getAsciiStream(String columnName) throws SQLException
340 {
341 return current.getAsciiStream(columnName);
342 }
343
344 public InputStream getUnicodeStream(String columnName) throws SQLException
345 {
346 return current.getUnicodeStream(columnName);
347 }
348
349 public InputStream getBinaryStream(String columnName) throws SQLException
350 {
351 return current.getBinaryStream(columnName);
352 }
353
354 public Reader getCharacterStream(String columnName) throws SQLException
355 {
356 return current.getCharacterStream(columnName);
357 }
358
359 public Reader getNCharacterStream(String columnName) throws SQLException
360 {
361 return current.getCharacterStream(columnName);
362 }
363
364 public Ref getRef(String columnName) throws SQLException
365 {
366 return current.getRef(columnName);
367 }
368
369 public RowId getRowId(String columnName) throws SQLException
370 {
371 return current.getRowId(columnName);
372 }
373
374 public Blob getBlob(String columnName) throws SQLException
375 {
376 return current.getBlob(columnName);
377 }
378
379 public Clob getClob(String columnName) throws SQLException
380 {
381 return current.getClob(columnName);
382 }
383
384 public NClob getNClob(String columnName) throws SQLException
385 {
386 return current.getNClob(columnName);
387 }
388
389 public SQLXML getSQLXML(String columnName) throws SQLException
390 {
391 return current.getSQLXML(columnName);
392 }
393
394 public Array getArray(String colName) throws SQLException
395 {
396 return current.getArray(colName);
397 }
398
399 public URL getURL(String columnName) throws SQLException
400 {
401 return current.getURL(columnName);
402 }
403
404 public Object getObject(String columnName) throws SQLException
405 {
406 return current.getObject(columnName);
407 }
408
409 public Object getObject(String columnName, Map map) throws SQLException
410 {
411 return current.getObject(columnName, map);
412 }
413
414 public SQLWarning getWarnings() throws SQLException
415 {
416 return current.getWarnings();
417 }
418
419 public void clearWarnings() throws SQLException
420 {
421 current.clearWarnings();
422 }
423
424 public String getCursorName() throws SQLException
425 {
426 return current.getCursorName();
427 }
428
429 public ResultSetMetaData getMetaData() throws SQLException
430 {
431 return current.getMetaData();
432 }
433
434 public int findColumn(String columnName) throws SQLException
435 {
436 return current.findColumn(columnName);
437 }
438
439 public boolean isBeforeFirst() throws SQLException
440 {
441 return current.isBeforeFirst();
442 }
443
444 public boolean isAfterLast() throws SQLException
445 {
446 return current.isAfterLast();
447 }
448
449 public boolean isFirst() throws SQLException
450 {
451 return current.isFirst();
452 }
453
454 public boolean isLast() throws SQLException
455 {
456 return current.isLast();
457 }
458
459 public void beforeFirst() throws SQLException
460 {
461 current.beforeFirst();
462 }
463
464 public void afterLast() throws SQLException
465 {
466 current.afterLast();
467 }
468
469 public boolean first() throws SQLException
470 {
471 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
472 }
473
474 public boolean last() throws SQLException
475 {
476 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
477 }
478
479 public int getRow() throws SQLException
480 {
481 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
482 }
483
484 public boolean absolute( int row ) throws SQLException
485 {
486 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
487 }
488
489 public boolean relative( int rows ) throws SQLException
490 {
491 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
492 }
493
494 public boolean previous() throws SQLException
495 {
496 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
497 }
498
499 public void setFetchDirection(int direction) throws SQLException
500 {
501 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
502 }
503
504 public int getFetchDirection() throws SQLException
505 {
506 return current.getFetchDirection();
507 }
508
509 public void setFetchSize(int rows) throws SQLException
510 {
511 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
512 }
513
514 public int getFetchSize() throws SQLException
515 {
516 return current.getFetchSize();
517 }
518
519 public int getType() throws SQLException
520 {
521 return current.getType();
522 }
523
524 public int getConcurrency() throws SQLException
525 {
526 return current.getConcurrency();
527 }
528
529 public int getHoldability() throws SQLException
530 {
531 return current.getHoldability();
532 }
533
534 public boolean rowUpdated() throws SQLException
535 {
536 return current.rowUpdated();
537 }
538
539 public boolean rowInserted() throws SQLException
540 {
541 return current.rowInserted();
542 }
543
544 public boolean rowDeleted() throws SQLException
545 {
546 return current.rowDeleted();
547 }
548
549 public void insertRow() throws SQLException
550 {
551 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
552 }
553
554 public void updateRow() throws SQLException
555 {
556 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
557 }
558
559 public void deleteRow() throws SQLException
560 {
561 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
562 }
563
564 public void refreshRow() throws SQLException
565 {
566 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
567 }
568
569 public void cancelRowUpdates() throws SQLException
570 {
571 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
572 }
573
574 public void moveToInsertRow() throws SQLException
575 {
576 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
577 }
578
579 public void moveToCurrentRow() throws SQLException
580 {
581 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
582 }
583
584 public Statement getStatement() throws SQLException
585 {
586 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
587 }
588
589 public void updateNull(int columnIndex) throws SQLException
590 {
591 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
592 }
593
594 public void updateBoolean(int columnIndex, boolean value) throws SQLException
595 {
596 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
597 }
598
599 public void updateByte(int columnIndex, byte value) throws SQLException
600 {
601 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
602 }
603
604 public void updateShort(int columnIndex, short value) throws SQLException
605 {
606 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
607 }
608
609 public void updateInt(int columnIndex, int value) throws SQLException
610 {
611 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
612 }
613
614 public void updateLong(int columnIndex, long value) throws SQLException
615 {
616 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
617 }
618
619 public void updateFloat(int columnIndex, float value) throws SQLException
620 {
621 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
622 }
623
624 public void updateDouble(int columnIndex, double value) throws SQLException
625 {
626 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
627 }
628
629 public void updateBigDecimal(int columnIndex, BigDecimal value) throws SQLException
630 {
631 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
632 }
633
634 public void updateString(int columnIndex, String value) throws SQLException
635 {
636 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
637 }
638
639 public void updateNString(int columnIndex, String value) throws SQLException
640 {
641 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
642 }
643
644 public void updateBytes(int columnIndex, byte value[]) throws SQLException
645 {
646 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
647 }
648
649 public void updateDate(int columnIndex, Date value) throws SQLException
650 {
651 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
652 }
653
654 public void updateTime(int columnIndex, Time value) throws SQLException
655 {
656 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
657 }
658
659 public void updateTimestamp(int columnIndex, Timestamp value) throws SQLException
660 {
661 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
662 }
663
664 public void updateAsciiStream(int columnIndex, InputStream stream, int length) throws SQLException
665 {
666 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
667 }
668
669 public void updateAsciiStream(int columnIndex, InputStream stream, long length) throws SQLException
670 {
671 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
672 }
673
674 public void updateAsciiStream(int columnIndex, InputStream stream) throws SQLException
675 {
676 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
677 }
678
679 public void updateBinaryStream(int columnIndex, InputStream stream, int length) throws SQLException
680 {
681 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
682 }
683
684 public void updateBinaryStream(int columnIndex, InputStream stream, long length) throws SQLException
685 {
686 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
687 }
688
689 public void updateBinaryStream(int columnIndex, InputStream stream) throws SQLException
690 {
691 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
692 }
693
694 public void updateCharacterStream(int columnIndex, Reader reader, int length) throws SQLException
695 {
696 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
697 }
698
699 public void updateCharacterStream(int columnIndex, Reader reader, long length) throws SQLException
700 {
701 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
702 }
703
704 public void updateCharacterStream(int columnIndex, Reader reader) throws SQLException
705 {
706 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
707 }
708
709 public void updateNCharacterStream(int columnIndex, Reader x, long length) throws SQLException
710 {
711 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
712 }
713
714 public void updateNCharacterStream(int columnIndex, Reader x) throws SQLException
715 {
716 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
717 }
718
719 public void updateRef(int columnIndex, Ref value) throws SQLException
720 {
721 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
722 }
723
724 public void updateRowId(int columnIndex, RowId x) throws SQLException
725 {
726 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
727 }
728
729 public void updateBlob(int columnIndex, InputStream stream, long length) throws SQLException
730 {
731 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
732 }
733
734 public void updateBlob(int columnIndex, Blob value) throws SQLException
735 {
736 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
737 }
738
739 public void updateBlob(int columnIndex, InputStream stream) throws SQLException
740 {
741 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
742 }
743
744 public void updateClob(int columnIndex, Clob value) throws SQLException
745 {
746 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
747 }
748
749 public void updateClob(int columnIndex, Reader reader, long length) throws SQLException
750 {
751 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
752 }
753
754 public void updateClob(int columnIndex, Reader reader) throws SQLException
755 {
756 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
757 }
758
759 public void updateNClob(int columnIndex, NClob nClob) throws SQLException
760 {
761 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
762 }
763
764 public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException
765 {
766 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
767 }
768
769 public void updateNClob(int columnIndex, Reader reader) throws SQLException
770 {
771 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
772 }
773
774 public void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException
775 {
776 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
777 }
778
779 public void updateArray(int columnIndex, Array value) throws SQLException
780 {
781 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
782 }
783
784 public void updateObject(int columnIndex, Object x, int scale) throws SQLException
785 {
786 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
787 }
788
789 public void updateObject(int columnIndex, Object x) throws SQLException
790 {
791 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
792 }
793
794 public void updateAsciiStream(String columnName, InputStream stream, int length) throws SQLException
795 {
796 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
797 }
798
799 public void updateAsciiStream(String columnName, InputStream stream) throws SQLException
800 {
801 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
802 }
803
804 public void updateAsciiStream(String columnName, InputStream stream, long length) throws SQLException
805 {
806 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
807 }
808
809 public void updateBinaryStream(String columnName, InputStream stream, long length) throws SQLException
810 {
811 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
812 }
813
814 public void updateBinaryStream(String columnName, InputStream stream) throws SQLException
815 {
816 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
817 }
818
819 public void updateCharacterStream(String columnName, Reader reader, int length) throws SQLException
820 {
821 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
822 }
823
824 public void updateCharacterStream(String columnName, Reader reader, long length) throws SQLException
825 {
826 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
827 }
828
829 public void updateCharacterStream(String columnName, Reader reader) throws SQLException
830 {
831 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
832 }
833
834 public void updateNCharacterStream(String columnName, Reader reader, long length) throws SQLException
835 {
836 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
837 }
838
839 public void updateNCharacterStream(String columnName, Reader reader) throws SQLException
840 {
841 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
842 }
843
844 public void updateNull(String columnName) throws SQLException
845 {
846 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
847 }
848
849 public void updateBoolean(String columnName, boolean value) throws SQLException
850 {
851 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
852 }
853
854 public void updateByte(String columnName, byte value) throws SQLException
855 {
856 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
857 }
858
859 public void updateShort(String columnName, short value) throws SQLException
860 {
861 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
862 }
863
864 public void updateInt(String columnName, int value) throws SQLException
865 {
866 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
867 }
868
869 public void updateLong(String columnName, long value) throws SQLException
870 {
871 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
872 }
873
874 public void updateFloat(String columnName, float value) throws SQLException
875 {
876 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
877 }
878
879 public void updateDouble(String columnName, double value) throws SQLException
880 {
881 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
882 }
883
884 public void updateBigDecimal(String columnName, BigDecimal value) throws SQLException
885 {
886 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
887 }
888
889 public void updateString(String columnName, String value) throws SQLException
890 {
891 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
892 }
893
894 public void updateNString(String columnName, String value) throws SQLException
895 {
896 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
897 }
898
899 public void updateBytes(String columnName, byte value[]) throws SQLException
900 {
901 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
902 }
903
904 public void updateDate(String columnName, Date value) throws SQLException
905 {
906 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
907 }
908
909 public void updateTime(String columnName, Time value) throws SQLException
910 {
911 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
912 }
913
914 public void updateTimestamp(String columnName, Timestamp value) throws SQLException
915 {
916 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
917 }
918
919 public void updateBinaryStream(String columnName, InputStream value, int length) throws SQLException
920 {
921 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
922 }
923
924 public void updateRef(String columnName, Ref value) throws SQLException
925 {
926 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
927 }
928
929 public void updateRowId(String columnName, RowId value) throws SQLException
930 {
931 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
932 }
933
934 public void updateBlob(String columnName, Blob value) throws SQLException
935 {
936 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
937 }
938
939 public void updateBlob(String columnName, InputStream stream, long length) throws SQLException
940 {
941 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
942 }
943
944 public void updateBlob(String columnName, InputStream stream) throws SQLException
945 {
946 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
947 }
948
949 public void updateClob(String columnName, Clob value) throws SQLException
950 {
951 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
952 }
953
954 public void updateClob(String columnName, Reader reader, long length) throws SQLException
955 {
956 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
957 }
958
959 public void updateClob(String columnName, Reader reader) throws SQLException
960 {
961 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
962 }
963
964 public void updateNClob(String columnName, NClob nClob) throws SQLException
965 {
966 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
967 }
968
969 public void updateNClob(String columnName, Reader reader, long length) throws SQLException
970 {
971 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
972 }
973
974 public void updateNClob(String columnName, Reader reader) throws SQLException
975 {
976 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
977 }
978
979 public void updateSQLXML(String columnName, SQLXML xmlObject) throws SQLException
980 {
981 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
982 }
983
984 public void updateArray(String columnName, Array value) throws SQLException
985 {
986 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
987 }
988
989 public void updateObject(String columnName, Object value, int scale) throws SQLException
990 {
991 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
992 }
993
994 public void updateObject(String columnName, Object value) throws SQLException
995 {
996 throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
997 }
998
999 public boolean isWrapperFor(Class iface) throws SQLException
1000 {
1001 return false;
1002 }
1003
1004 public Object unwrap(Class iface) throws SQLException
1005 {
1006 throw new SQLException("No object found for " + iface);
1007 }
1008 }
1009
1010