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