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.Ref;
012    import java.sql.ResultSet;
013    import java.sql.ResultSetMetaData;
014    import java.sql.SQLException;
015    import java.sql.SQLWarning;
016    import java.sql.Statement;
017    import java.sql.Time;
018    import java.sql.Timestamp;
019    import java.util.Calendar;
020    import java.util.Collections;
021    import java.util.List;
022    
023    /** 
024     * Contains a list of <code>ResultSet</code> objects where the <code>next()</code> 
025     * method iterates through all <code>ResultSet</code> objects in the list.
026     * The get-methods and <code>next()</code> can be used. All update-methods
027     * and scroll-methods throw an <code>SQLException</code>.
028     */
029    public class PolyResultSet implements ResultSet 
030    {
031        private List resultSets;
032        private int position;
033        private ResultSet current;
034    
035        public PolyResultSet(List resultSets) 
036        {
037            this.resultSets = resultSets;
038        }
039    
040        public List getUnderlyingResultSetList()
041        {
042            return Collections.unmodifiableList(resultSets);
043        }
044        
045        public boolean next() throws SQLException 
046        {
047            if((current != null) && current.next()) 
048            {
049                return true;
050            } 
051            else 
052            {
053                while(position < resultSets.size()) 
054                {
055                    current = (ResultSet)resultSets.get(position++);
056                    if(current.next()) return true;
057                }
058            }
059            return false;
060        }
061    
062        /** 
063         * Does nothing.
064         */
065        public void close() throws SQLException 
066        {
067            
068        }
069    
070        public boolean wasNull() throws SQLException 
071        {
072            return current.wasNull();
073        }
074        
075        public String getString(int columnIndex) throws SQLException 
076        {
077            return current.getString(columnIndex);
078        }
079    
080        public boolean getBoolean(int columnIndex) throws SQLException
081        {
082            return current.getBoolean(columnIndex);
083        }
084    
085        public byte getByte(int columnIndex) throws SQLException
086        {
087            return current.getByte(columnIndex);
088        }
089    
090        public short getShort(int columnIndex) throws SQLException
091        {
092            return current.getShort(columnIndex);
093        }
094    
095        public int getInt(int columnIndex) throws SQLException
096        {
097            return current.getInt(columnIndex);
098        }
099    
100        public long getLong(int columnIndex) throws SQLException
101        {
102            return current.getLong(columnIndex);
103        }
104    
105        public float getFloat(int columnIndex) throws SQLException
106        {
107            return current.getFloat(columnIndex);
108        }
109    
110        public double getDouble(int columnIndex) throws SQLException
111        {
112            return current.getDouble(columnIndex);
113        }
114    
115        public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException
116        {
117            return current.getBigDecimal(columnIndex);
118        }
119    
120        public byte[] getBytes(int columnIndex) throws SQLException
121        {
122            return current.getBytes(columnIndex);
123        }
124    
125        public Date getDate(int columnIndex) throws SQLException
126        {
127            return current.getDate(columnIndex);
128        }
129    
130        public Time getTime(int columnIndex) throws SQLException
131        {
132            return current.getTime(columnIndex);
133        }
134    
135        public Timestamp getTimestamp(int columnIndex) throws SQLException
136        {
137            return current.getTimestamp(columnIndex);
138        }
139    
140        public InputStream getAsciiStream(int columnIndex) throws SQLException
141        {
142            return current.getAsciiStream(columnIndex);
143        }
144    
145        public InputStream getUnicodeStream(int columnIndex) throws SQLException
146        {
147            return current.getUnicodeStream(columnIndex);
148        }
149    
150        public InputStream getBinaryStream(int columnIndex) throws SQLException
151        {
152            return current.getBinaryStream(columnIndex);
153        }
154    
155    
156        public String getString(String columnName) throws SQLException
157        {
158            return current.getString(columnName);
159        }
160    
161        public boolean getBoolean(String columnName) throws SQLException
162        {
163            return current.getBoolean(columnName);
164        }
165    
166        public byte getByte(String columnName) throws SQLException
167        {
168            return current.getByte(columnName);
169        }
170    
171        public short getShort(String columnName) throws SQLException
172        {
173            return current.getShort(columnName);
174        }
175    
176        public int getInt(String columnName) throws SQLException
177        {
178            return current.getInt(columnName);
179        }
180    
181        public long getLong(String columnName) throws SQLException
182        {
183            return current.getLong(columnName);
184        }
185    
186        public float getFloat(String columnName) throws SQLException
187        {
188            return current.getFloat(columnName);
189        }
190    
191        public double getDouble(String columnName) throws SQLException
192        {
193            return current.getDouble(columnName);
194        }
195    
196        public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException
197        {
198            return current.getBigDecimal(columnName);
199        }
200    
201        public byte[] getBytes(String columnName) throws SQLException
202        {
203            return current.getBytes(columnName);
204        }
205    
206        public Date getDate(String columnName) throws SQLException
207        {
208            return current.getDate(columnName);
209        }
210    
211        public Time getTime(String columnName) throws SQLException
212        {
213            return current.getTime(columnName);
214        }
215    
216        public Timestamp getTimestamp(String columnName) throws SQLException
217        {
218            return current.getTimestamp(columnName);
219        }
220    
221        public InputStream getAsciiStream(String columnName) throws SQLException
222        {
223            return current.getAsciiStream(columnName);
224        }
225    
226        public InputStream getUnicodeStream(String columnName) throws SQLException
227        {
228            return current.getUnicodeStream(columnName);
229        }
230    
231        public InputStream getBinaryStream(String columnName) throws SQLException
232        {
233            return current.getBinaryStream(columnName);
234        }
235    
236        public SQLWarning getWarnings() throws SQLException
237        {
238            return current.getWarnings();
239        }
240    
241        public void clearWarnings() throws SQLException
242        {
243            current.clearWarnings();
244        }
245    
246        public String getCursorName() throws SQLException
247        {
248            return current.getCursorName();
249        }
250    
251        public ResultSetMetaData getMetaData() throws SQLException
252        {
253            return current.getMetaData();
254        }
255    
256        public Object getObject(int columnIndex) throws SQLException
257        {
258            return current.getObject(columnIndex);
259        }
260    
261        public Object getObject(String columnName) throws SQLException
262        {
263            return current.getObject(columnName);
264        }
265    
266        public int findColumn(String columnName) throws SQLException
267        {
268            return current.findColumn(columnName);
269        }
270    
271        public Reader getCharacterStream(int columnIndex) throws SQLException
272        {
273            return current.getCharacterStream(columnIndex);
274        }
275    
276        public Reader getCharacterStream(String columnName) throws SQLException
277        {
278            return current.getCharacterStream(columnName);
279        }
280    
281        public BigDecimal getBigDecimal(int columnIndex) throws SQLException
282        {
283            return current.getBigDecimal(columnIndex);
284        }
285    
286        public BigDecimal getBigDecimal(String columnName) throws SQLException
287        {
288            return current.getBigDecimal(columnName);
289        }
290    
291        public boolean isBeforeFirst() throws SQLException
292        {
293            return current.isBeforeFirst();
294        }
295          
296        public boolean isAfterLast() throws SQLException
297        {
298            return current.isAfterLast();
299        }
300     
301        public boolean isFirst() throws SQLException
302        {
303            return current.isFirst();
304        }
305     
306        public boolean isLast() throws SQLException
307        {
308            return current.isLast();
309        }
310    
311        public void beforeFirst() throws SQLException
312        {
313            current.beforeFirst();
314        }
315    
316        public void afterLast() throws SQLException
317        {
318            current.afterLast();
319        }
320    
321        public boolean first() throws SQLException
322        {
323            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
324        }
325    
326        public boolean last() throws SQLException
327        {
328            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
329        }
330    
331        public int getRow() throws SQLException
332        {
333            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
334        }
335    
336        public boolean absolute( int row ) throws SQLException
337        {
338            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
339        }
340    
341        public boolean relative( int rows ) throws SQLException
342        {
343            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
344        }
345    
346        public boolean previous() throws SQLException
347        {
348            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
349        }
350    
351        public void setFetchDirection(int direction) throws SQLException
352        {
353            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
354        }
355    
356        public int getFetchDirection() throws SQLException
357        {
358            return current.getFetchDirection();
359        }
360    
361        public void setFetchSize(int rows) throws SQLException
362        {
363            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
364        }
365    
366        public int getFetchSize() throws SQLException
367        {
368            return current.getFetchSize();
369        }
370    
371        public int getType() throws SQLException
372        {
373            return current.getType();
374        }
375    
376        public int getConcurrency() throws SQLException
377        {
378            return current.getConcurrency();
379        }
380    
381        public boolean rowUpdated() throws SQLException
382        {
383            return current.rowUpdated();
384        }
385    
386        public boolean rowInserted() throws SQLException
387        {
388            return current.rowInserted();
389        }
390       
391        public boolean rowDeleted() throws SQLException
392        {
393            return current.rowDeleted();
394        }
395    
396        public void updateNull(int columnIndex) throws SQLException  
397        {
398            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
399        }
400    
401        public void updateBoolean(int columnIndex, boolean x) throws SQLException
402        {
403            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
404        }
405    
406        public void updateByte(int columnIndex, byte x) throws SQLException
407        {
408            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
409        }
410    
411        public void updateShort(int columnIndex, short x) throws SQLException
412        {
413            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
414        }
415    
416        public void updateInt(int columnIndex, int x) throws SQLException
417        {
418            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
419        }
420    
421        public void updateLong(int columnIndex, long x) throws SQLException
422        {
423            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
424        }
425    
426        public void updateFloat(int columnIndex, float x) throws SQLException
427        {
428            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
429        }
430    
431        public void updateDouble(int columnIndex, double x) throws SQLException
432        {
433            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
434        }
435    
436        public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException
437        {
438            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
439        }
440    
441        public void updateString(int columnIndex, String x) throws SQLException
442        {
443            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
444        }
445    
446        public void updateBytes(int columnIndex, byte x[]) throws SQLException
447        {
448            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
449        }
450    
451        public void updateDate(int columnIndex, Date x) throws SQLException
452        {
453            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
454        }
455    
456        public void updateTime(int columnIndex, Time x) throws SQLException
457        {
458            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
459        }
460    
461        public void updateTimestamp(int columnIndex, Timestamp x) throws SQLException
462        {
463            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
464        }
465    
466        public void updateAsciiStream(int columnIndex, InputStream x, int length) throws SQLException
467        {
468            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
469        }
470    
471        public void updateBinaryStream(int columnIndex, InputStream x, int length) throws SQLException
472        {
473            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
474        }
475    
476        public void updateCharacterStream(int columnIndex, Reader x, int length) throws SQLException
477        {
478            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
479        }
480    
481        public void updateObject(int columnIndex, Object x, int scale) throws SQLException
482        {
483            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
484        }
485    
486        public void updateObject(int columnIndex, Object x) throws SQLException
487        {
488            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
489        }
490    
491        public void updateNull(String columnName) throws SQLException  
492        {
493            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
494        }
495    
496        public void updateBoolean(String columnName, boolean x) throws SQLException
497        {
498            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
499        }
500    
501        public void updateByte(String columnName, byte x) throws SQLException
502        {
503            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
504        }
505    
506        public void updateShort(String columnName, short x) throws SQLException
507        {
508            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
509        }
510    
511        public void updateInt(String columnName, int x) throws SQLException
512        {
513            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
514        }
515    
516        public void updateLong(String columnName, long x) throws SQLException
517        {
518            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
519        }
520    
521        public void updateFloat(String columnName, float x) throws SQLException
522        {
523            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
524        }
525    
526        public void updateDouble(String columnName, double x) throws SQLException
527        {
528            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
529        }
530    
531        public void updateBigDecimal(String columnName, BigDecimal x) throws SQLException
532        {
533            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
534        }
535    
536        public void updateString(String columnName, String x) throws SQLException
537        {
538            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
539        }
540    
541        public void updateBytes(String columnName, byte x[]) throws SQLException
542        {
543            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
544        }
545    
546        public void updateDate(String columnName, Date x) throws SQLException
547        {
548            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
549        }
550    
551        public void updateTime(String columnName, Time x) throws SQLException
552        {
553            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
554        }
555    
556        public void updateTimestamp(String columnName, Timestamp x) throws SQLException
557        {
558            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
559        }
560    
561        public void updateAsciiStream(String columnName, InputStream x, int length) throws SQLException
562        {
563            current.updateAsciiStream(columnName, x, length);
564        }
565    
566        public void updateBinaryStream(String columnName, InputStream x, int length) throws SQLException
567        {
568            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
569        }
570    
571        public void updateCharacterStream(String columnName, Reader reader, int length) throws SQLException
572        {
573            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
574        }
575    
576        public void updateObject(String columnName, Object x, int scale) throws SQLException
577        {
578            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
579        }
580    
581        public void updateObject(String columnName, Object x) throws SQLException
582        {
583            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
584        }
585    
586        public void insertRow() throws SQLException
587        {
588            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
589        }
590    
591        public void updateRow() throws SQLException
592        {
593            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
594        }
595    
596        public void deleteRow() throws SQLException
597        {
598            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
599        }
600    
601        public void refreshRow() throws SQLException
602        {
603            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
604        }
605    
606        public void cancelRowUpdates() throws SQLException
607        {
608            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
609        }
610    
611        public void moveToInsertRow() throws SQLException
612        {
613            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
614        }
615    
616        public void moveToCurrentRow() throws SQLException
617        {
618            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
619        }
620    
621        public Statement getStatement() throws SQLException
622        {
623            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
624        }
625    
626        public Object getObject(int i, java.util.Map map) throws SQLException
627        {
628            return current.getObject(i, map);
629        }
630    
631        public Ref getRef(int i) throws SQLException
632        {
633            return current.getRef(i);
634        }
635    
636        public Blob getBlob(int i) throws SQLException
637        {
638            return current.getBlob(i);
639        }
640    
641        public Clob getClob(int i) throws SQLException
642        {
643            return current.getClob(i);
644        }
645    
646        public Array getArray(int i) throws SQLException
647        {
648            return current.getArray(i);
649        }
650    
651        public Object getObject(String colName, java.util.Map map) throws SQLException
652        {
653            return current.getObject(colName, map);
654        }
655    
656        public Ref getRef(String colName) throws SQLException
657        {
658            return current.getRef(colName);
659        }
660    
661        public Blob getBlob(String colName) throws SQLException
662        {
663            return current.getBlob(colName);
664        }
665    
666        public Clob getClob(String colName) throws SQLException
667        {
668            return current.getClob(colName);
669        }
670    
671        public Array getArray(String colName) throws SQLException
672        {
673            return current.getArray(colName);
674        }
675    
676        public Date getDate(int columnIndex, Calendar cal) throws SQLException
677        {
678            return current.getDate(columnIndex, cal);
679        }
680    
681        public Date getDate(String columnName, Calendar cal) throws SQLException
682        {
683            return current.getDate(columnName, cal);
684        }
685    
686        public Time getTime(int columnIndex, Calendar cal) throws SQLException
687        {
688            return current.getTime(columnIndex, cal);
689        }
690    
691        public Time getTime(String columnName, Calendar cal) throws SQLException
692        {
693            return current.getTime(columnName, cal);
694        }
695    
696        public Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException
697        {
698            return current.getTimestamp(columnIndex, cal);
699        }
700    
701        public Timestamp getTimestamp(String columnName, Calendar cal)      throws SQLException
702        {
703            return current.getTimestamp(columnName, cal);
704        }
705    
706        public URL getURL(int columnIndex) throws SQLException
707        {
708            return current.getURL(columnIndex);
709        }
710    
711        public URL getURL(String columnName) throws SQLException
712        {
713            return current.getURL(columnName);
714        }
715    
716        public void updateRef(int columnIndex, Ref x) throws SQLException
717        {
718            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
719        }
720        
721        public void updateRef(String columnName, Ref x) throws SQLException
722        {
723            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
724        }
725    
726        public void updateBlob(int columnIndex, Blob x) throws SQLException
727        {
728            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
729        }
730    
731        public void updateBlob(String columnName, Blob x) throws SQLException
732        {
733            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
734        }
735    
736        public void updateClob(int columnIndex, Clob x) throws SQLException
737        {
738            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
739        }
740    
741        public void updateClob(String columnName, Clob x) throws SQLException
742        {
743            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
744        }
745    
746        public void updateArray(int columnIndex, Array x) throws SQLException
747        {
748            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
749        }
750    
751        public void updateArray(String columnName, Array x) throws SQLException
752        {
753            throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
754        }
755    }
756    
757