001    package railo.runtime.cfx;
002    
003    
004    import java.io.InputStream;
005    import java.io.Reader;
006    import java.math.BigDecimal;
007    import java.net.URL;
008    import java.sql.Array;
009    import java.sql.Blob;
010    import java.sql.Clob;
011    import java.sql.Date;
012    import java.sql.Ref;
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.Iterator;
021    import java.util.Map;
022    
023    
024    //JDK6: uncomment this for compiling with JDK6 
025    import java.sql.NClob;
026    import java.sql.RowId;
027    import java.sql.SQLXML;
028    
029    
030    import railo.runtime.PageContext;
031    import railo.runtime.dump.DumpData;
032    import railo.runtime.dump.DumpProperties;
033    import railo.runtime.exp.PageException;
034    import railo.runtime.type.Collection.Key;
035    
036    import com.allaire.cfx.Query;
037    
038    /**
039     * Implementation of the Query Interface
040     */
041    public class QueryWrap implements Query {
042            
043    
044            private railo.runtime.type.Query rst;
045            private String name;
046    
047            /**
048             * constructor of the class
049             * @param rst runtime Query
050             */
051            public QueryWrap(railo.runtime.type.Query rst) {
052                    this.rst=rst;
053                    this.name=rst.getName();
054            }
055            /**
056             * constructor of the class
057             * @param rst runtime Query
058             * @param name name of the query (otherwise rst.getName())
059             */
060            public QueryWrap(railo.runtime.type.Query rst, String name) {
061                    this.rst=rst;
062                    this.name=name;
063            }
064    
065            /**
066             * @see com.allaire.cfx.Query#addRow()
067             */
068            public int addRow() {
069                    return rst.addRow();
070            }
071    
072            /**
073             * @see com.allaire.cfx.Query#getColumnIndex(java.lang.String)
074             */
075            public int getColumnIndex(String coulmnName) {
076                    return rst.getColumnIndex(coulmnName);
077            }
078    
079            /**
080             * @see com.allaire.cfx.Query#getColumns()
081             */
082            public String[] getColumns() {
083                    return rst.getColumns();
084            }
085            
086            /*
087            FUTURE
088            public Collection.Key[] getColumnNames() {
089            return rst.getColumnNames();
090        }
091        
092    
093            public String[] getColumnNamesAsString() {
094                    return rst.getColumnNamesAsString();
095            }*/
096    
097            /**
098             * @see com.allaire.cfx.Query#getData(int, int)
099             */
100            public String getData(int row, int col) throws IndexOutOfBoundsException {
101                    return rst.getData(row,col);
102            }
103    
104            /**
105             * @see com.allaire.cfx.Query#getName()
106             */
107            public String getName() {
108                    return name;
109            }
110    
111            /**
112             * @see com.allaire.cfx.Query#getRowCount()
113             */
114            public int getRowCount() {
115                    return rst.getRowCount();
116            }
117    
118            /**
119             * @see com.allaire.cfx.Query#setData(int, int, java.lang.String)
120             */
121            public void setData(int row, int col, String value) throws IndexOutOfBoundsException {
122                rst.setData(row,col,value);
123            }
124            
125            
126            /**
127             * @see java.sql.ResultSet#absolute(int)
128             */
129            public boolean absolute(int row) throws SQLException {  
130                    return rst.absolute(row);
131            }
132            /**
133             * @see java.sql.ResultSet#afterLast()
134             */
135            public void afterLast() throws SQLException {
136                    rst.afterLast();
137            }
138            /**
139             * @see java.sql.ResultSet#beforeFirst()
140             */
141            public void beforeFirst() throws SQLException { 
142                    rst.beforeFirst();
143            }
144            /**
145             * @see java.sql.ResultSet#cancelRowUpdates()
146             */
147            public void cancelRowUpdates() throws SQLException {    
148                    rst.cancelRowUpdates();
149            }
150            /**
151             * @see java.sql.ResultSet#clearWarnings()
152             */
153            public void clearWarnings() throws SQLException {
154                    rst.clearWarnings();
155            }
156            
157            /**
158             * @see java.lang.Object#clone()
159             */
160            public Object clone() { 
161                    return rst.clone();
162            }
163            /**
164             * @see java.sql.ResultSet#close()
165             */
166            public void close() throws SQLException {       
167                    rst.close();
168            }
169            /**
170             * @see java.sql.ResultSet#deleteRow()
171             */
172            public void deleteRow() throws SQLException {   
173                    rst.deleteRow();
174            }
175            /**
176             * @see java.sql.ResultSet#findColumn(java.lang.String)
177             */
178            public int findColumn(String columnName) throws SQLException {
179                    return rst.findColumn(columnName);
180            }
181            /**
182             * @see java.sql.ResultSet#first()
183             */
184            public boolean first() throws SQLException {    
185                    return rst.first();
186            }
187            /**
188             * @see java.sql.ResultSet#getArray(int)
189             */
190            public Array getArray(int i) throws SQLException {
191                    return rst.getArray(i);
192            }
193            /**
194             * @see java.sql.ResultSet#getArray(java.lang.String)
195             */
196            public Array getArray(String colName) throws SQLException {
197                    return rst.getArray(colName);
198            }
199            /**
200             * @see java.sql.ResultSet#getAsciiStream(int)
201             */
202            public InputStream getAsciiStream(int columnIndex) throws SQLException {
203                    return rst.getAsciiStream(columnIndex);
204            }
205            /**
206             * @see java.sql.ResultSet#getAsciiStream(java.lang.String)
207             */
208            public InputStream getAsciiStream(String columnName) throws SQLException {      
209                    return rst.getAsciiStream(columnName);
210            }
211            /**
212             * @see java.sql.ResultSet#getBigDecimal(int, int)
213             */
214            public BigDecimal getBigDecimal(int columnIndex, int scale)throws SQLException {
215                    return rst.getBigDecimal(columnIndex, scale);
216            }
217            /**
218             * @see java.sql.ResultSet#getBigDecimal(int)
219             */
220            public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
221                    return rst.getBigDecimal(columnIndex);
222            }
223            /**
224             * @see java.sql.ResultSet#getBigDecimal(java.lang.String, int)
225             */
226            public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException {
227                    return rst.getBigDecimal(columnName, scale);
228            }
229            /**
230             * @see java.sql.ResultSet#getBigDecimal(java.lang.String)
231             */
232            public BigDecimal getBigDecimal(String columnName) throws SQLException {
233                    return rst.getBigDecimal(columnName);
234            }
235            /**
236             * @see java.sql.ResultSet#getBinaryStream(int)
237             */
238            public InputStream getBinaryStream(int columnIndex) throws SQLException {
239                    return rst.getBinaryStream(columnIndex);
240            }
241            /**
242             * @see java.sql.ResultSet#getBinaryStream(java.lang.String)
243             */
244            public InputStream getBinaryStream(String columnName) throws SQLException {
245                    return rst.getBinaryStream(columnName);
246            }
247            /**
248             * @see java.sql.ResultSet#getBlob(int)
249             */
250            public Blob getBlob(int i) throws SQLException {
251                    return rst.getBlob(i);
252            }
253            /**
254             * @see java.sql.ResultSet#getBlob(java.lang.String)
255             */
256            public Blob getBlob(String colName) throws SQLException {
257                    return rst.getBlob(colName);
258            }
259            /**
260             * @see java.sql.ResultSet#getBoolean(int)
261             */
262            public boolean getBoolean(int columnIndex) throws SQLException {
263                    return rst.getBoolean(columnIndex);
264            }
265            /**
266             * @see java.sql.ResultSet#getBoolean(java.lang.String)
267             */
268            public boolean getBoolean(String columnName) throws SQLException {
269                    return rst.getBoolean(columnName);
270            }
271            /**
272             * @see java.sql.ResultSet#getByte(int)
273             */
274            public byte getByte(int columnIndex) throws SQLException {
275                    return rst.getByte(columnIndex);
276            }
277            /**
278             * @see java.sql.ResultSet#getByte(java.lang.String)
279             */
280            public byte getByte(String columnName) throws SQLException {
281                    return rst.getByte(columnName);
282            }
283            /**
284             * @see java.sql.ResultSet#getBytes(int)
285             */
286            public byte[] getBytes(int columnIndex) throws SQLException {
287                    return rst.getBytes(columnIndex);
288            }
289            /**
290             * @see java.sql.ResultSet#getBytes(java.lang.String)
291             */
292            public byte[] getBytes(String columnName) throws SQLException {
293                    return rst.getBytes(columnName);
294            }
295            /**
296             * @see java.sql.ResultSet#getCharacterStream(int)
297             */
298            public Reader getCharacterStream(int columnIndex) throws SQLException { 
299                    return rst.getCharacterStream(columnIndex);
300            }
301            /**
302             * @see java.sql.ResultSet#getCharacterStream(java.lang.String)
303             */
304            public Reader getCharacterStream(String columnName) throws SQLException {
305                    return rst.getCharacterStream(columnName);
306            }
307            /**
308             * @see java.sql.ResultSet#getClob(int)
309             */
310            public Clob getClob(int i) throws SQLException {        
311                    return rst.getClob(i);
312            }
313            /**
314             * @see java.sql.ResultSet#getClob(java.lang.String)
315             */
316            public Clob getClob(String colName) throws SQLException {
317                    return rst.getClob(colName);
318            }
319            /**
320             * @see java.sql.ResultSet#getConcurrency()
321             */
322            public int getConcurrency() throws SQLException {       
323                    return rst.getConcurrency();
324            }
325            /**
326             * @see java.sql.ResultSet#getCursorName()
327             */
328            public String getCursorName() throws SQLException {
329                    return rst.getCursorName();
330            }
331            /**
332             * @see java.sql.ResultSet#getDate(int, java.util.Calendar)
333             */
334            public Date getDate(int columnIndex, Calendar cal) throws SQLException {
335                    return rst.getDate(columnIndex, cal);
336            }
337            /**
338             * @see java.sql.ResultSet#getDate(int)
339             */
340            public Date getDate(int columnIndex) throws SQLException {
341                    return rst.getDate(columnIndex);
342            }
343            /**
344             * @see java.sql.ResultSet#getDate(java.lang.String, java.util.Calendar)
345             */
346            public Date getDate(String columnName, Calendar cal) throws SQLException {
347                    return rst.getDate(columnName, cal);
348            }
349            /**
350             * @see java.sql.ResultSet#getDate(java.lang.String)
351             */
352            public Date getDate(String columnName) throws SQLException {
353                    return rst.getDate(columnName);
354            }
355            /**
356             * @see java.sql.ResultSet#getDouble(int)
357             */
358            public double getDouble(int columnIndex) throws SQLException {
359                    return rst.getDouble(columnIndex);
360            }
361            /**
362             * @see java.sql.ResultSet#getDouble(java.lang.String)
363             */
364            public double getDouble(String columnName) throws SQLException {
365                    return rst.getDouble(columnName);
366            }
367            /**
368             * @see java.sql.ResultSet#getFetchDirection()
369             */
370            public int getFetchDirection() throws SQLException {
371                    return rst.getFetchDirection();
372            }
373            /**
374             * @see java.sql.ResultSet#getFetchSize()
375             */
376            public int getFetchSize() throws SQLException {
377                    return rst.getFetchSize();
378            }
379            /**
380             * @see java.sql.ResultSet#getFloat(int)
381             */
382            public float getFloat(int columnIndex) throws SQLException {
383                    return rst.getFloat(columnIndex);
384            }
385            /**
386             * @see java.sql.ResultSet#getFloat(java.lang.String)
387             */
388            public float getFloat(String columnName) throws SQLException {
389                    return rst.getFloat(columnName);
390            }
391            /**
392             * @see java.sql.ResultSet#getInt(int)
393             */
394            public int getInt(int columnIndex) throws SQLException {
395                    return rst.getInt(columnIndex);
396            }
397            /**
398             * @see java.sql.ResultSet#getInt(java.lang.String)
399             */
400            public int getInt(String columnName) throws SQLException {
401                    return rst.getInt(columnName);
402            }
403            /**
404             * @see java.sql.ResultSet#getLong(int)
405             */
406            public long getLong(int columnIndex) throws SQLException {
407                    return rst.getLong(columnIndex);
408            }
409            /**
410             * @see java.sql.ResultSet#getLong(java.lang.String)
411             */
412            public long getLong(String columnName) throws SQLException {
413                    return rst.getLong(columnName);
414            }
415            /**
416             * @see java.sql.ResultSet#getMetaData()
417             */
418            public ResultSetMetaData getMetaData() throws SQLException {    
419                    return rst.getMetaData();
420            }
421            /**
422             * @see java.sql.ResultSet#getObject(int, java.util.Map)
423             */
424            public Object getObject(int i, Map map) throws SQLException {
425                    return rst.getObject(i, map);
426            }
427            /**
428             * @see java.sql.ResultSet#getObject(int)
429             */
430            public Object getObject(int columnIndex) throws SQLException {
431                    return rst.getObject(columnIndex);
432            }
433            /**
434             * @see java.sql.ResultSet#getObject(java.lang.String, java.util.Map)
435             */
436            public Object getObject(String colName, Map map) throws SQLException {
437                    return rst.getObject(colName, map);
438            }
439            /**
440             * @see java.sql.ResultSet#getObject(java.lang.String)
441             */
442            public Object getObject(String columnName) throws SQLException {
443                    return rst.getObject(columnName);
444            }
445            /**
446             * @return recordcount of the query
447             */
448            public int getRecordcount() {
449                    return rst.getRecordcount();
450            }
451            /**
452             * @see java.sql.ResultSet#getRef(int)
453             */
454            public Ref getRef(int i) throws SQLException {
455                    return rst.getRef(i);
456            }
457            /**
458             * @see java.sql.ResultSet#getRef(java.lang.String)
459             */
460            public Ref getRef(String colName) throws SQLException {
461                    return rst.getRef(colName);
462            }
463            /**
464             * @see java.sql.ResultSet#getRow()
465             */
466            public int getRow() throws SQLException {
467                    return rst.getRow();
468            }
469            /**
470             * @see java.sql.ResultSet#getShort(int)
471             */
472            public short getShort(int columnIndex) throws SQLException {
473                    return rst.getShort(columnIndex);
474            }
475            /**
476             * @see java.sql.ResultSet#getShort(java.lang.String)
477             */
478            public short getShort(String columnName) throws SQLException {  
479                    return rst.getShort(columnName);
480            }
481            /**
482             * @see java.sql.ResultSet#getStatement()
483             */
484            public Statement getStatement() throws SQLException {
485                    return rst.getStatement();
486            }
487            /**
488             * @see java.sql.ResultSet#getString(int)
489             */
490            public String getString(int columnIndex) throws SQLException {
491                    return rst.getString(columnIndex);
492            }
493            /**
494             * @see java.sql.ResultSet#getString(java.lang.String)
495             */
496            public String getString(String columnName) throws SQLException {
497                    return rst.getString(columnName);
498            }
499            /**
500             * @see java.sql.ResultSet#getTime(int, java.util.Calendar)
501             */
502            public Time getTime(int columnIndex, Calendar cal) throws SQLException {
503                    return rst.getTime(columnIndex, cal);
504            }
505            /**
506             * @see java.sql.ResultSet#getTime(int)
507             */
508            public Time getTime(int columnIndex) throws SQLException {
509                    return rst.getTime(columnIndex);
510            }
511            /**
512             * @see java.sql.ResultSet#getTime(java.lang.String, java.util.Calendar)
513             */
514            public Time getTime(String columnName, Calendar cal) throws SQLException {
515                    return rst.getTime(columnName, cal);
516            }
517            /**
518             * @see java.sql.ResultSet#getTime(java.lang.String)
519             */
520            public Time getTime(String columnName) throws SQLException {
521                    return rst.getTime(columnName);
522            }
523            /**
524             * @see java.sql.ResultSet#getTimestamp(int, java.util.Calendar)
525             */
526            public Timestamp getTimestamp(int columnIndex, Calendar cal)throws SQLException {       
527                    return rst.getTimestamp(columnIndex, cal);
528            }
529            /**
530             * @see java.sql.ResultSet#getTimestamp(int)
531             */
532            public Timestamp getTimestamp(int columnIndex) throws SQLException {
533                    return rst.getTimestamp(columnIndex);
534            }
535            /**
536             * @see java.sql.ResultSet#getTimestamp(java.lang.String, java.util.Calendar)
537             */
538            public Timestamp getTimestamp(String columnName, Calendar cal)
539                            throws SQLException {
540                    return rst.getTimestamp(columnName, cal);
541            }
542            /**
543             * @see java.sql.ResultSet#getTimestamp(java.lang.String)
544             */
545            public Timestamp getTimestamp(String columnName) throws SQLException {
546                    return rst.getTimestamp(columnName);
547            }
548            /**
549             * @see java.sql.ResultSet#getType()
550             */
551            public int getType() throws SQLException {      
552                    return rst.getType();
553            }
554            /**
555             * @see java.sql.ResultSet#getUnicodeStream(int)
556             */
557            public InputStream getUnicodeStream(int columnIndex) throws SQLException {
558                    return rst.getUnicodeStream(columnIndex);
559            }
560            /**
561             * @see java.sql.ResultSet#getUnicodeStream(java.lang.String)
562             */
563            public InputStream getUnicodeStream(String columnName) throws SQLException {
564                    return rst.getUnicodeStream(columnName);
565            }
566            /**
567             * @see java.sql.ResultSet#getURL(int)
568             */
569            public URL getURL(int columnIndex) throws SQLException {
570                    return rst.getURL(columnIndex);
571            }
572            /**
573             * @see java.sql.ResultSet#getURL(java.lang.String)
574             */
575            public URL getURL(String columnName) throws SQLException {
576                    return rst.getURL(columnName);
577            }
578            /**
579             * @see java.sql.ResultSet#getWarnings()
580             */
581            public SQLWarning getWarnings() throws SQLException {
582                    return rst.getWarnings();
583            }
584            /**
585             * @see java.sql.ResultSet#insertRow()
586             */
587            public void insertRow() throws SQLException {
588                    rst.insertRow();
589            }
590            /**
591             * @see java.sql.ResultSet#isAfterLast()
592             */
593            public boolean isAfterLast() throws SQLException {
594                    
595                    return rst.isAfterLast();
596            }
597            /**
598             * @see java.sql.ResultSet#isBeforeFirst()
599             */
600            public boolean isBeforeFirst() throws SQLException {
601                    return rst.isBeforeFirst();
602            }
603            /**
604             * @return is cached
605             */
606            public boolean isCached() {
607                    return rst.isCached();
608            }
609            /**
610             * @return has records
611             */
612            public boolean isEmpty() {
613                    return rst.isEmpty();
614            }
615            /**
616             * @see java.sql.ResultSet#isFirst()
617             */
618            public boolean isFirst() throws SQLException {
619                    return rst.isFirst();
620            }
621            /**
622             * @see java.sql.ResultSet#isLast()
623             */
624            public boolean isLast() throws SQLException {
625                    return rst.isLast();
626            }
627            /**
628             * @return iterator for he keys
629             */
630            public Iterator keyIterator() {
631                    return rst.keyIterator();
632            }
633            /**
634             * @return all keys of the Query
635             */
636            public Key[] keys() {
637                    return rst.keys();
638            }
639            /**
640             * @see java.sql.ResultSet#last()
641             */
642            public boolean last() throws SQLException {
643                    
644                    return rst.last();
645            }
646            
647            
648            
649            /**
650             * @see java.sql.ResultSet#moveToCurrentRow()
651             */
652            public void moveToCurrentRow() throws SQLException {
653                    rst.moveToCurrentRow();
654            }
655            /**
656             * @see java.sql.ResultSet#moveToInsertRow()
657             */
658            public void moveToInsertRow() throws SQLException {
659                    rst.moveToInsertRow();
660            }
661            /**
662             * @see java.sql.ResultSet#next()
663             */
664            public boolean next() {
665                    return rst.next();
666            }
667            /**
668             * @see java.sql.ResultSet#previous()
669             */
670            public boolean previous()  throws SQLException{
671                    return rst.previous();
672            }
673            /**
674             * @see java.sql.ResultSet#refreshRow()
675             */
676            public void refreshRow() throws SQLException {
677                    rst.refreshRow();
678            }
679            /**
680             * @see java.sql.ResultSet#relative(int)
681             */
682            public boolean relative(int rows) throws SQLException {
683                    return rst.relative(rows);
684            }
685            /**
686             * @see java.sql.ResultSet#rowDeleted()
687             */
688            public boolean rowDeleted() throws SQLException {
689                    return rst.rowDeleted();
690            }
691            /**
692             * @see java.sql.ResultSet#rowInserted()
693             */
694            public boolean rowInserted() throws SQLException {
695                    return rst.rowInserted();
696            }
697            /**
698             * @see java.sql.ResultSet#rowUpdated()
699             */
700            public boolean rowUpdated() throws SQLException {
701                    return rst.rowUpdated();
702            }
703            
704            /**
705             * @see java.sql.ResultSet#setFetchDirection(int)
706             */
707            public void setFetchDirection(int direction) throws SQLException {
708                    rst.setFetchDirection(direction);
709            }
710            /**
711             * @see java.sql.ResultSet#setFetchSize(int)
712             */
713            public void setFetchSize(int rows) throws SQLException {
714                    rst.setFetchSize(rows);
715            }
716            
717            /**
718             * @return the size of the query
719             */
720            public int size() {     
721                    return rst.size();
722            }
723            /**
724             * @param keyColumn
725             * @param order
726             * @throws PageException
727             */
728            public synchronized void sort(Key keyColumn, int order)
729                            throws PageException {
730                    
731                    rst.sort(keyColumn, order);
732            }
733            /**
734             * @param column
735             * @throws PageException
736             */
737            public void sort(Key column) throws PageException {
738                    
739                    rst.sort(column);
740            }
741            /**
742             * @param strColumn
743             * @param order
744             * @throws PageException
745             */
746            public synchronized void sort(String strColumn, int order)
747                            throws PageException {
748                    
749                    rst.sort(strColumn, order);
750            }
751            /**
752             * @param column
753             * @throws PageException
754             */
755            public void sort(String column) throws PageException {
756                    
757                    rst.sort(column);
758            }
759            /**
760             * @param pageContext
761             * @param maxlevel
762             * @param dp
763             * @return generated DumpData
764             */
765            public DumpData toDumpData(PageContext pageContext, int maxlevel,DumpProperties dp) {
766                    return rst.toDumpData(pageContext, maxlevel, dp);
767            }
768            /**
769             * @see java.lang.Object#toString()
770             */
771            public String toString() {
772                    return rst.toString();
773            }
774            /**
775             * @see java.sql.ResultSet#updateArray(int, java.sql.Array)
776             */
777            public void updateArray(int columnIndex, Array x) throws SQLException {
778                    rst.updateArray(columnIndex, x);
779            }
780            /**
781             * @see java.sql.ResultSet#updateArray(java.lang.String, java.sql.Array)
782             */
783            public void updateArray(String columnName, Array x) throws SQLException {
784                    rst.updateArray(columnName, x);
785            }
786            /**
787             * @see java.sql.ResultSet#updateAsciiStream(int, java.io.InputStream, int)
788             */
789            public void updateAsciiStream(int columnIndex, InputStream x, int length)
790                            throws SQLException {
791                    rst.updateAsciiStream(columnIndex, x, length);
792            }
793            /**
794             * @see java.sql.ResultSet#updateAsciiStream(java.lang.String, java.io.InputStream, int)
795             */
796            public void updateAsciiStream(String columnName, InputStream x, int length)
797                            throws SQLException {
798                    
799                    rst.updateAsciiStream(columnName, x, length);
800            }
801            /**
802             * @see java.sql.ResultSet#updateBigDecimal(int, java.math.BigDecimal)
803             */
804            public void updateBigDecimal(int columnIndex, BigDecimal x)
805                            throws SQLException {
806                    
807                    rst.updateBigDecimal(columnIndex, x);
808            }
809            /**
810             * @see java.sql.ResultSet#updateBigDecimal(java.lang.String, java.math.BigDecimal)
811             */
812            public void updateBigDecimal(String columnName, BigDecimal x)
813                            throws SQLException {
814                    
815                    rst.updateBigDecimal(columnName, x);
816            }
817            /**
818             * @see java.sql.ResultSet#updateBinaryStream(int, java.io.InputStream, int)
819             */
820            public void updateBinaryStream(int columnIndex, InputStream x, int length)
821                            throws SQLException {
822                    
823                    rst.updateBinaryStream(columnIndex, x, length);
824            }
825            /**
826             * @see java.sql.ResultSet#updateBinaryStream(java.lang.String, java.io.InputStream, int)
827             */
828            public void updateBinaryStream(String columnName, InputStream x, int length)
829                            throws SQLException {
830                    
831                    rst.updateBinaryStream(columnName, x, length);
832            }
833            /**
834             * @see java.sql.ResultSet#updateBlob(int, java.sql.Blob)
835             */
836            public void updateBlob(int columnIndex, Blob x) throws SQLException {
837                    
838                    rst.updateBlob(columnIndex, x);
839            }
840            /**
841             * @see java.sql.ResultSet#updateBlob(java.lang.String, java.sql.Blob)
842             */
843            public void updateBlob(String columnName, Blob x) throws SQLException {
844                    
845                    rst.updateBlob(columnName, x);
846            }
847            /**
848             * @see java.sql.ResultSet#updateBoolean(int, boolean)
849             */
850            public void updateBoolean(int columnIndex, boolean x) throws SQLException {
851                    
852                    rst.updateBoolean(columnIndex, x);
853            }
854            /**
855             * @see java.sql.ResultSet#updateBoolean(java.lang.String, boolean)
856             */
857            public void updateBoolean(String columnName, boolean x) throws SQLException {
858                    
859                    rst.updateBoolean(columnName, x);
860            }
861            /**
862             * @see java.sql.ResultSet#updateByte(int, byte)
863             */
864            public void updateByte(int columnIndex, byte x) throws SQLException {
865                    
866                    rst.updateByte(columnIndex, x);
867            }
868            /**
869             * @see java.sql.ResultSet#updateByte(java.lang.String, byte)
870             */
871            public void updateByte(String columnName, byte x) throws SQLException {
872                    
873                    rst.updateByte(columnName, x);
874            }
875            /**
876             * @see java.sql.ResultSet#updateBytes(int, byte[])
877             */
878            public void updateBytes(int columnIndex, byte[] x) throws SQLException {
879                    
880                    rst.updateBytes(columnIndex, x);
881            }
882            /**
883             * @see java.sql.ResultSet#updateBytes(java.lang.String, byte[])
884             */
885            public void updateBytes(String columnName, byte[] x) throws SQLException {
886                    rst.updateBytes(columnName, x);
887            }
888            /**
889             * @see java.sql.ResultSet#updateCharacterStream(int, java.io.Reader, int)
890             */
891            public void updateCharacterStream(int columnIndex, Reader reader, int length)
892                            throws SQLException {
893                    
894                    rst.updateCharacterStream(columnIndex, reader, length);
895            }
896            /**
897             * @see java.sql.ResultSet#updateCharacterStream(java.lang.String, java.io.Reader, int)
898             */
899            public void updateCharacterStream(String columnName, Reader reader,
900                            int length) throws SQLException {
901                    rst.updateCharacterStream(columnName, reader, length);
902            }
903            /**
904             * @see java.sql.ResultSet#updateClob(int, java.sql.Clob)
905             */
906            public void updateClob(int columnIndex, Clob x) throws SQLException {
907                    rst.updateClob(columnIndex, x);
908            }
909            /**
910             * @see java.sql.ResultSet#updateClob(java.lang.String, java.sql.Clob)
911             */
912            public void updateClob(String columnName, Clob x) throws SQLException {
913                    rst.updateClob(columnName, x);
914            }
915            /**
916             * @see java.sql.ResultSet#updateDate(int, java.sql.Date)
917             */
918            public void updateDate(int columnIndex, Date x) throws SQLException {   
919                    rst.updateDate(columnIndex, x);
920            }
921            /**
922             * @see java.sql.ResultSet#updateDate(java.lang.String, java.sql.Date)
923             */
924            public void updateDate(String columnName, Date x) throws SQLException {
925                    rst.updateDate(columnName, x);
926            }
927            /**
928             * @see java.sql.ResultSet#updateDouble(int, double)
929             */
930            public void updateDouble(int columnIndex, double x) throws SQLException {
931                    rst.updateDouble(columnIndex, x);
932            }
933            /**
934             * @see java.sql.ResultSet#updateDouble(java.lang.String, double)
935             */
936            public void updateDouble(String columnName, double x) throws SQLException {
937                    rst.updateDouble(columnName, x);
938            }
939            /**
940             * @see java.sql.ResultSet#updateFloat(int, float)
941             */
942            public void updateFloat(int columnIndex, float x) throws SQLException {
943                    rst.updateFloat(columnIndex, x);
944            }
945            /**
946             * @see java.sql.ResultSet#updateFloat(java.lang.String, float)
947             */
948            public void updateFloat(String columnName, float x) throws SQLException {
949                    rst.updateFloat(columnName, x);
950            }
951            /**
952             * @see java.sql.ResultSet#updateInt(int, int)
953             */
954            public void updateInt(int columnIndex, int x) throws SQLException {
955                    rst.updateInt(columnIndex, x);
956            }
957            /**
958             * @see java.sql.ResultSet#updateInt(java.lang.String, int)
959             */
960            public void updateInt(String columnName, int x) throws SQLException {
961                    rst.updateInt(columnName, x);
962            }
963            /**
964             * @see java.sql.ResultSet#updateLong(int, long)
965             */
966            public void updateLong(int columnIndex, long x) throws SQLException {
967                    rst.updateLong(columnIndex, x);
968            }
969            /**
970             * @see java.sql.ResultSet#updateLong(java.lang.String, long)
971             */
972            public void updateLong(String columnName, long x) throws SQLException {
973                    rst.updateLong(columnName, x);
974            }
975            /**
976             * @see java.sql.ResultSet#updateNull(int)
977             */
978            public void updateNull(int columnIndex) throws SQLException {
979                    rst.updateNull(columnIndex);
980            }
981            /**
982             * @see java.sql.ResultSet#updateNull(java.lang.String)
983             */
984            public void updateNull(String columnName) throws SQLException {
985                    rst.updateNull(columnName);
986            }
987            /**
988             * @see java.sql.ResultSet#updateObject(int, java.lang.Object, int)
989             */
990            public void updateObject(int columnIndex, Object x, int scale)
991                            throws SQLException {
992                    rst.updateObject(columnIndex, x, scale);
993            }
994            /**
995             * @see java.sql.ResultSet#updateObject(int, java.lang.Object)
996             */
997            public void updateObject(int columnIndex, Object x) throws SQLException {
998                    rst.updateObject(columnIndex, x);
999            }
1000            /**
1001             * @see java.sql.ResultSet#updateObject(java.lang.String, java.lang.Object, int)
1002             */
1003            public void updateObject(String columnName, Object x, int scale)
1004                            throws SQLException {
1005                    rst.updateObject(columnName, x, scale);
1006            }
1007            /**
1008             * @see java.sql.ResultSet#updateObject(java.lang.String, java.lang.Object)
1009             */
1010            public void updateObject(String columnName, Object x) throws SQLException {
1011                    rst.updateObject(columnName, x);
1012            }
1013            /**
1014             * @see java.sql.ResultSet#updateRef(int, java.sql.Ref)
1015             */
1016            public void updateRef(int columnIndex, Ref x) throws SQLException {
1017                    rst.updateRef(columnIndex, x);
1018            }
1019            /**
1020             * @see java.sql.ResultSet#updateRef(java.lang.String, java.sql.Ref)
1021             */
1022            public void updateRef(String columnName, Ref x) throws SQLException {
1023                    rst.updateRef(columnName, x);
1024            }
1025            /**
1026             * @see java.sql.ResultSet#updateRow()
1027             */
1028            public void updateRow() throws SQLException {
1029                    rst.updateRow();
1030            }
1031            /**
1032             * @see java.sql.ResultSet#updateShort(int, short)
1033             */
1034            public void updateShort(int columnIndex, short x) throws SQLException {
1035                    rst.updateShort(columnIndex, x);
1036            }
1037            /**
1038             * @see java.sql.ResultSet#updateShort(java.lang.String, short)
1039             */
1040            public void updateShort(String columnName, short x) throws SQLException {
1041                    rst.updateShort(columnName, x);
1042            }
1043            /**
1044             * @see java.sql.ResultSet#updateString(int, java.lang.String)
1045             */
1046            public void updateString(int columnIndex, String x) throws SQLException {
1047                    rst.updateString(columnIndex, x);
1048            }
1049            /**
1050             * @see java.sql.ResultSet#updateString(java.lang.String, java.lang.String)
1051             */
1052            public void updateString(String columnName, String x) throws SQLException {
1053                    rst.updateString(columnName, x);
1054            }
1055            /**
1056             * @see java.sql.ResultSet#updateTime(int, java.sql.Time)
1057             */
1058            public void updateTime(int columnIndex, Time x) throws SQLException {
1059                    rst.updateTime(columnIndex, x);
1060            }
1061            /**
1062             * @see java.sql.ResultSet#updateTime(java.lang.String, java.sql.Time)
1063             */
1064            public void updateTime(String columnName, Time x) throws SQLException {
1065                    rst.updateTime(columnName, x);
1066            }
1067            /**
1068             * @see java.sql.ResultSet#updateTimestamp(int, java.sql.Timestamp)
1069             */
1070            public void updateTimestamp(int columnIndex, Timestamp x)
1071                            throws SQLException {
1072                    rst.updateTimestamp(columnIndex, x);
1073            }
1074            /**
1075             * @see java.sql.ResultSet#updateTimestamp(java.lang.String, java.sql.Timestamp)
1076             */
1077            public void updateTimestamp(String columnName, Timestamp x)
1078                            throws SQLException {
1079                    rst.updateTimestamp(columnName, x);
1080            }
1081            /**
1082             * @see java.sql.ResultSet#wasNull()
1083             */
1084            public boolean wasNull()  throws SQLException{
1085                    return rst.wasNull();
1086            }
1087            public railo.runtime.type.Query getQuery() {
1088                    return rst;
1089            }
1090            public int getHoldability() throws SQLException {
1091                    throw notSupported();
1092            }
1093            public Reader getNCharacterStream(int arg0) throws SQLException {
1094                    throw notSupported();
1095            }
1096            public Reader getNCharacterStream(String arg0) throws SQLException {
1097                    throw notSupported();
1098            }
1099            public String getNString(int arg0) throws SQLException {
1100                    throw notSupported();
1101            }
1102            public String getNString(String arg0) throws SQLException {
1103                    throw notSupported();
1104            }
1105            public boolean isClosed() throws SQLException {
1106                    throw notSupported();
1107            }
1108            public void updateAsciiStream(int arg0, InputStream arg1)throws SQLException {
1109                    throw notSupported();
1110            }
1111            public void updateAsciiStream(String arg0, InputStream arg1)throws SQLException {
1112                    throw notSupported();
1113            }
1114            public void updateAsciiStream(int arg0, InputStream arg1, long arg2)
1115                            throws SQLException {
1116                    throw notSupported();
1117            }
1118            public void updateAsciiStream(String arg0, InputStream arg1, long arg2)
1119                            throws SQLException {
1120                    throw notSupported();
1121            }
1122            public void updateBinaryStream(int arg0, InputStream arg1)
1123                            throws SQLException {
1124                    throw notSupported();
1125            }
1126            public void updateBinaryStream(String arg0, InputStream arg1)
1127                            throws SQLException {
1128                    throw notSupported();
1129            }
1130            public void updateBinaryStream(int arg0, InputStream arg1, long arg2)
1131                            throws SQLException {
1132                    throw notSupported();
1133            }
1134            public void updateBinaryStream(String arg0, InputStream arg1, long arg2)
1135                            throws SQLException {
1136                    throw notSupported();
1137            }
1138            public void updateBlob(int arg0, InputStream arg1) throws SQLException {
1139                    throw notSupported();
1140            }
1141            public void updateBlob(String arg0, InputStream arg1) throws SQLException {
1142                    throw notSupported();
1143            }
1144            public void updateBlob(int arg0, InputStream arg1, long arg2)
1145                            throws SQLException {
1146                    throw notSupported();
1147            }
1148            public void updateBlob(String arg0, InputStream arg1, long arg2)
1149                            throws SQLException {
1150                    throw notSupported();
1151            }
1152            public void updateCharacterStream(int arg0, Reader arg1)
1153                            throws SQLException {
1154                    throw notSupported();
1155            }
1156            public void updateCharacterStream(String arg0, Reader arg1)
1157                            throws SQLException {
1158                    throw notSupported();
1159            }
1160            public void updateCharacterStream(int arg0, Reader arg1, long arg2)
1161                            throws SQLException {
1162                    throw notSupported();
1163            }
1164            public void updateCharacterStream(String arg0, Reader arg1, long arg2)
1165                            throws SQLException {
1166                    throw notSupported();
1167            }
1168            public void updateClob(int arg0, Reader arg1) throws SQLException {
1169                    throw notSupported();
1170            }
1171            public void updateClob(String arg0, Reader arg1) throws SQLException {
1172                    throw notSupported();
1173            }
1174            public void updateClob(int arg0, Reader arg1, long arg2)
1175                            throws SQLException {
1176                    throw notSupported();
1177            }
1178            public void updateClob(String arg0, Reader arg1, long arg2)
1179                            throws SQLException {
1180                    throw notSupported();
1181            }
1182            public void updateNCharacterStream(int arg0, Reader arg1)
1183                            throws SQLException {
1184                    throw notSupported();
1185            }
1186            public void updateNCharacterStream(String arg0, Reader arg1)
1187                            throws SQLException {
1188                    throw notSupported();
1189            }
1190            public void updateNCharacterStream(int arg0, Reader arg1, long arg2)
1191                            throws SQLException {
1192                    throw notSupported();
1193            }
1194            public void updateNCharacterStream(String arg0, Reader arg1, long arg2)
1195                            throws SQLException {
1196                    throw notSupported();
1197            }
1198            public void updateNClob(int arg0, Reader arg1) throws SQLException {
1199                    throw notSupported();
1200            }
1201            public void updateNClob(String arg0, Reader arg1) throws SQLException {
1202                    throw notSupported();
1203            }
1204            public void updateNClob(int arg0, Reader arg1, long arg2)
1205                            throws SQLException {
1206                    throw notSupported();
1207            }
1208            public void updateNClob(String arg0, Reader arg1, long arg2)
1209                            throws SQLException {
1210                    throw notSupported();
1211            }
1212            public void updateNString(int arg0, String arg1) throws SQLException {
1213                    throw notSupported();
1214            }
1215            public void updateNString(String arg0, String arg1) throws SQLException {
1216                    throw notSupported();
1217            }
1218            public boolean isWrapperFor(Class<?> arg0) throws SQLException {
1219                    throw notSupported();
1220            }
1221            public <T> T unwrap(Class<T> arg0) throws SQLException {
1222                    throw notSupported();
1223            }
1224    
1225            //JDK6: uncomment this for compiling with JDK6 
1226            public NClob getNClob(int arg0) throws SQLException {
1227                    return rst.getNClob(arg0);
1228            }
1229            public NClob getNClob(String arg0) throws SQLException {
1230                    return rst.getNClob(arg0);
1231            }
1232            public RowId getRowId(int arg0) throws SQLException {
1233                    return rst.getRowId(arg0);
1234            }
1235            public RowId getRowId(String arg0) throws SQLException {
1236                    return rst.getRowId(arg0);
1237            }
1238            public SQLXML getSQLXML(int arg0) throws SQLException {
1239                    return rst.getSQLXML(arg0);
1240            }
1241            public SQLXML getSQLXML(String arg0) throws SQLException {
1242                    return rst.getSQLXML(arg0);
1243            }
1244            public void updateNClob(int arg0, NClob arg1) throws SQLException {
1245                    rst.updateNClob(arg0, arg1);
1246            }
1247            public void updateNClob(String arg0, NClob arg1) throws SQLException {
1248                    rst.updateNClob(arg0, arg1);
1249            }
1250            public void updateRowId(int arg0, RowId arg1) throws SQLException {
1251                    rst.updateRowId(arg0, arg1);
1252            }
1253            public void updateRowId(String arg0, RowId arg1) throws SQLException {
1254                    rst.updateRowId(arg0, arg1);
1255            }
1256            public void updateSQLXML(int arg0, SQLXML arg1) throws SQLException {
1257                    rst.updateSQLXML(arg0, arg1);
1258            }
1259            public void updateSQLXML(String arg0, SQLXML arg1) throws SQLException {
1260                    rst.updateSQLXML(arg0, arg1);
1261            }
1262            
1263            
1264            
1265            
1266            
1267            
1268    
1269            private SQLException notSupported() {
1270                    return new SQLException("this feature is not supported");
1271            }
1272            private RuntimeException notSupportedEL() {
1273                    return new RuntimeException(new SQLException("this feature is not supported"));
1274            }
1275    }