001    package railo.runtime.query;
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.Blob;
008    import java.sql.Clob;
009    import java.sql.Date;
010    import java.sql.Ref;
011    import java.sql.ResultSetMetaData;
012    import java.sql.SQLException;
013    import java.sql.SQLWarning;
014    import java.sql.Statement;
015    import java.sql.Time;
016    import java.sql.Timestamp;
017    import java.util.Calendar;
018    import java.util.HashMap;
019    import java.util.Iterator;
020    import java.util.Map;
021    
022    import railo.runtime.PageContext;
023    import railo.runtime.db.SQL;
024    import railo.runtime.dump.DumpData;
025    import railo.runtime.dump.DumpProperties;
026    import railo.runtime.exp.DatabaseException;
027    import railo.runtime.exp.ExpressionException;
028    import railo.runtime.exp.PageException;
029    import railo.runtime.type.Array;
030    import railo.runtime.type.Collection;
031    import railo.runtime.type.KeyImpl;
032    import railo.runtime.type.Query;
033    import railo.runtime.type.QueryColumn;
034    import railo.runtime.type.QueryImpl;
035    import railo.runtime.type.Struct;
036    import railo.runtime.type.dt.DateTime;
037    
038    public class QueryCacheQuery extends QueryImpl {
039    
040            private QueryImpl query;
041            private boolean isCloned=false;
042            private Map _columns=new HashMap();
043    
044            public QueryCacheQuery(QueryImpl query) throws DatabaseException {
045                    super(query.keys(),0,query.getName());
046                    this.query=query;
047            }
048    
049            protected void disconnectCache() {
050                    if(isCloned) return;
051                    this.query=query.cloneQuery(true);
052                    isCloned=true;
053            }
054    
055            /**
056             * @see railo.runtime.type.QueryImpl#addColumn(java.lang.String, railo.runtime.type.Array)
057             */
058            public boolean addColumn(String columnName, Array content) throws DatabaseException {
059                    disconnectCache();
060                    return query.addColumn(columnName, content);
061            }
062    
063            /**
064             * @see railo.runtime.type.QueryImpl#addColumn(railo.runtime.type.Collection.Key, railo.runtime.type.Array)
065             */
066            public boolean addColumn(Collection.Key columnName, Array content) throws PageException {
067                    disconnectCache();
068                    return query.addColumn(columnName, content);
069            }
070    
071            /**
072             * @see railo.runtime.type.QueryImpl#addColumn(java.lang.String, railo.runtime.type.Array, int)
073             */
074            public synchronized boolean addColumn(String columnName, Array content, int type) throws DatabaseException {
075                    disconnectCache();
076                    return query.addColumn(columnName, content, type);
077            }
078    
079            /**
080             * @see railo.runtime.type.QueryImpl#addColumn(railo.runtime.type.Collection.Key, railo.runtime.type.Array, int)
081             */
082            public boolean addColumn(Collection.Key columnName, Array content, int type) throws DatabaseException {
083                    disconnectCache();
084                    return query.addColumn(columnName, content, type);
085            }
086    
087            /**
088             * @see railo.runtime.type.QueryImpl#addRow(int)
089             */
090            public synchronized boolean addRow(int count) {
091                    disconnectCache();
092                    return query.addRow(count);
093            }
094    
095            /**
096             * @see railo.runtime.type.QueryImpl#addRow()
097             */
098            public int addRow() {
099                    disconnectCache();
100                    return query.addRow();
101            }
102    
103            /**
104             * @see railo.runtime.type.QueryImpl#call(railo.runtime.PageContext, java.lang.String, java.lang.Object[])
105             */
106            public Object call(PageContext pc, String methodName, Object[] arguments) throws PageException {
107                    return query.call(pc, methodName, arguments);
108            }
109    
110            /**
111             * @see railo.runtime.type.QueryImpl#call(railo.runtime.PageContext, railo.runtime.type.Collection.Key, java.lang.Object[])
112             */
113            public Object call(PageContext pc, Collection.Key methodName, Object[] arguments) throws PageException {
114                    return query.call(pc, methodName, arguments);
115            }
116    
117            /**
118             * @see railo.runtime.type.QueryImpl#callWithNamedValues(railo.runtime.PageContext, java.lang.String, railo.runtime.type.Struct)
119             */
120            public Object callWithNamedValues(PageContext pc, String methodName, Struct args) throws PageException {
121                    return query.callWithNamedValues(pc, methodName, args);
122            }
123    
124            /**
125             * @see railo.runtime.type.QueryImpl#callWithNamedValues(railo.runtime.PageContext, railo.runtime.type.Collection.Key, railo.runtime.type.Struct)
126             */
127            public Object callWithNamedValues(PageContext pc, Collection.Key methodName, Struct args) throws PageException {
128                    return query.callWithNamedValues(pc, methodName, args);
129            }
130    
131            /**
132             * @see railo.runtime.type.QueryImpl#castToBooleanValue()
133             */
134            public boolean castToBooleanValue() throws ExpressionException {
135                    return query.castToBooleanValue();
136            }
137        
138        /**
139         * @see railo.runtime.op.Castable#castToBoolean(java.lang.Boolean)
140         */
141        public Boolean castToBoolean(Boolean defaultValue) {
142            return query.castToBoolean(defaultValue);
143        }
144    
145            /**
146             * @see railo.runtime.type.QueryImpl#castToDateTime()
147             */
148            public DateTime castToDateTime() throws ExpressionException {
149                    return query.castToDateTime();
150            }
151        
152        /**
153         * @see railo.runtime.op.Castable#castToDateTime(railo.runtime.type.dt.DateTime)
154         */
155        public DateTime castToDateTime(DateTime defaultValue) {
156            return query.castToDateTime(defaultValue);
157        }
158    
159            /**
160             * @see railo.runtime.type.QueryImpl#castToDoubleValue()
161             */
162            public double castToDoubleValue() throws ExpressionException {
163                    return query.castToDoubleValue();
164            }
165        
166        /**
167         * @see railo.runtime.op.Castable#castToDoubleValue(double)
168         */
169        public double castToDoubleValue(double defaultValue) {
170            return query.castToDoubleValue(defaultValue);
171        }
172    
173            /**
174             * @see railo.runtime.type.QueryImpl#castToString()
175             */
176            public String castToString() throws ExpressionException {
177                    return query.castToString();
178            }
179            
180            /**
181             * @see railo.runtime.type.util.StructSupport#castToString(java.lang.String)
182             */
183            public String castToString(String defaultValue) {
184                    return query.castToString(defaultValue);
185            }
186    
187            /**
188             * @see railo.runtime.type.QueryImpl#clear()
189             */
190            public void clear() {
191                    disconnectCache();
192                    query.clear();
193            }
194    
195            /**
196             * @see railo.runtime.type.QueryImpl#clone()
197             */
198            public Object clone() {
199                    return query.clone();
200            }
201    
202            /**
203             * @see railo.runtime.type.QueryImpl#cloneQuery(boolean)
204             */
205            public QueryImpl cloneQuery(boolean deepCopy) {
206                    return query.cloneQuery(deepCopy);
207            }
208    
209            /**
210             * @see railo.runtime.type.QueryImpl#compareTo(boolean)
211             */
212            public int compareTo(boolean b) throws ExpressionException {
213                    return query.compareTo(b);
214            }
215    
216            /**
217             * @see railo.runtime.type.QueryImpl#compareTo(railo.runtime.type.dt.DateTime)
218             */
219            public int compareTo(DateTime dt) throws PageException {
220                    return query.compareTo(dt);
221            }
222    
223            /**
224             * @see railo.runtime.type.QueryImpl#compareTo(double)
225             */
226            public int compareTo(double d) throws PageException {
227                    return query.compareTo(d);
228            }
229    
230            /**
231             * @see railo.runtime.type.QueryImpl#compareTo(java.lang.String)
232             */
233            public int compareTo(String str) throws PageException {
234                    return query.compareTo(str);
235            }
236    
237            /**
238             * @see railo.runtime.type.QueryImpl#containsKey(java.lang.String)
239             */
240            public boolean containsKey(String key) {
241                    return query.containsKey(key);
242            }
243    
244            /**
245             * @see railo.runtime.type.QueryImpl#containsKey(railo.runtime.type.Collection.Key)
246             */
247            public boolean containsKey(Collection.Key key) {
248                    return query.containsKey(key);
249            }
250    
251            /**
252             * @see railo.runtime.type.QueryImpl#cutRowsTo(int)
253             */
254            public synchronized boolean cutRowsTo(int maxrows) {
255                    disconnectCache();
256                    return query.cutRowsTo(maxrows);
257            }
258    
259            /**
260             * @see railo.runtime.type.QueryImpl#duplicate(boolean)
261             */
262            public Collection duplicate(boolean deepCopy) {
263                    return query.duplicate(deepCopy);
264            }
265    
266            /**
267             * @see railo.runtime.type.QueryImpl#executionTime()
268             */
269            public int executionTime() {
270                    return query.executionTime();
271            }
272    
273            /**
274             * @see railo.runtime.type.QueryImpl#get(java.lang.String, java.lang.Object)
275             */
276            public Object get(String key, Object defaultValue) {
277                    return query.get(key, defaultValue);
278            }
279    
280            /**
281             * @see railo.runtime.type.QueryImpl#get(railo.runtime.type.Collection.Key, java.lang.Object)
282             */
283            public Object get(Collection.Key key, Object defaultValue) {
284                    return query.get(key, defaultValue);
285            }
286    
287            /**
288             * @see railo.runtime.type.QueryImpl#get(java.lang.String)
289             */
290            public Object get(String key) throws PageException {
291                    return query.get(key);
292            }
293    
294            /**
295             * @see railo.runtime.type.QueryImpl#get(railo.runtime.type.Collection.Key)
296             */
297            public Object get(Collection.Key key) throws PageException {
298                    return query.get(key);
299            }
300    
301            /**
302             * @see railo.runtime.type.QueryImpl#get(railo.runtime.PageContext, java.lang.String, java.lang.Object)
303             */
304            public Object get(PageContext pc, String key, Object defaultValue) {
305                    return query.get(pc, key, defaultValue);
306            }
307    
308            /**
309             * @see railo.runtime.type.QueryImpl#get(railo.runtime.PageContext, railo.runtime.type.Collection.Key, java.lang.Object)
310             */
311            public Object get(PageContext pc, Collection.Key key, Object defaultValue) {
312                    return query.get(pc, key, defaultValue);
313            }
314    
315            /**
316             * @see railo.runtime.type.QueryImpl#get(railo.runtime.PageContext, java.lang.String)
317             */
318            public Object get(PageContext pc, String key) throws PageException {
319                    return query.get(pc, key);
320            }
321    
322            /**
323             * @see railo.runtime.type.QueryImpl#get(railo.runtime.PageContext, railo.runtime.type.Collection.Key)
324             */
325            public Object get(PageContext pc, Collection.Key key) throws PageException {
326                    return query.get(pc, key);
327            }
328    
329            /**
330             * @see railo.runtime.type.QueryImpl#getAt(java.lang.String, int, java.lang.Object)
331             */
332            public Object getAt(String key, int row, Object defaultValue) {
333                    return query.getAt(key, row, defaultValue);
334            }
335    
336            /**
337             * @see railo.runtime.type.QueryImpl#getAt(railo.runtime.type.Collection.Key, int, java.lang.Object)
338             */
339            public Object getAt(Collection.Key key, int row, Object defaultValue) {
340                    return query.getAt(key, row, defaultValue);
341            }
342    
343            /**
344             * @see railo.runtime.type.QueryImpl#getAt(java.lang.String, int)
345             */
346            public Object getAt(String key, int row) throws PageException {
347                    return query.getAt(key, row);
348            }
349    
350            /**
351             * @see railo.runtime.type.QueryImpl#getAt(railo.runtime.type.Collection.Key, int)
352             */
353            public Object getAt(Collection.Key key, int row) throws PageException {
354                    return query.getAt(key, row);
355            }
356    
357            /**
358             * @see railo.runtime.type.QueryImpl#getBoolean(int)
359             */
360            public boolean getBoolean(int columnIndex) throws SQLException {
361                    return query.getBoolean(columnIndex);
362            }
363    
364            /**
365             * @see railo.runtime.type.QueryImpl#getBoolean(java.lang.String)
366             */
367            public boolean getBoolean(String columnName) throws SQLException {
368                    return query.getBoolean(columnName);
369            }
370    
371            /**
372             * @see railo.runtime.type.QueryImpl#getColumn(java.lang.String)
373             */
374            public QueryColumn getColumn(String key) throws DatabaseException {
375                    return getColumn(KeyImpl.getInstance(key));
376            }
377    
378            /**
379             * @see railo.runtime.type.QueryImpl#getColumn(railo.runtime.type.Collection.Key)
380             */
381            public QueryColumn getColumn(Collection.Key key) throws DatabaseException {
382                    if(!isCloned) {
383                            QueryColumn column = (QueryColumn) _columns.get(key);
384                            if(column==null) {
385                                    column=QueryCacheQueryColumn.getColumn(this,key);
386                                    _columns.put(key, column);
387                            }
388                            return column;
389                    }
390                    //disconnectCache();
391                    return query.getColumn(key);
392            }
393    
394            /**
395             * @see railo.runtime.type.QueryImpl#getColumn(java.lang.String, railo.runtime.type.QueryColumn)
396             */
397            public QueryColumn getColumn(String key, QueryColumn defaultValue) {
398                    return getColumn(KeyImpl.getInstance(key),defaultValue);
399            }
400    
401            /**
402             * @see railo.runtime.type.QueryImpl#getColumn(railo.runtime.type.Collection.Key, railo.runtime.type.QueryColumn)
403             */
404            public QueryColumn getColumn(Collection.Key key, QueryColumn defaultValue) {
405                    if(!isCloned) {
406                            QueryColumn column = (QueryColumn) _columns.get(key);
407                            if(column==null) {
408                                    column=QueryCacheQueryColumn.getColumn(this,key,defaultValue);
409                                    if(column!=defaultValue)_columns.put(key, column);
410                            }
411                            return column;
412                    }
413                    //disconnectCache();
414                    return query.getColumn(key, defaultValue);
415            }
416    
417            /**
418             * @see railo.runtime.type.QueryImpl#getColumnIndex(java.lang.String)
419             */
420            public int getColumnIndex(String coulmnName) {
421                    return query.getColumnIndex(coulmnName);
422            }
423    
424            /**
425             * @see railo.runtime.type.QueryImpl#getColumnlist()
426             */
427            public String getColumnlist() {
428                    return query.getColumnlist();
429            }
430    
431            /**
432             * @see railo.runtime.type.QueryImpl#getColumns()
433             */
434            public String[] getColumns() {
435                    return query.getColumns();
436            }
437    
438            /**
439             * @see railo.runtime.type.QueryImpl#getCurrentrow()
440             */
441            public int getCurrentrow() {
442                    return query.getCurrentrow();
443            }
444    
445            /**
446             * @see railo.runtime.type.QueryImpl#getCurrentrow(int)
447             */
448            public int getCurrentrow(int pid) {
449                    return query.getCurrentrow(pid);
450            }
451    
452            /**
453             * @see railo.runtime.type.QueryImpl#getData(int, int)
454             */
455            public String getData(int row, int col) throws IndexOutOfBoundsException {
456                    return query.getData(row, col);
457            }
458            
459            /**
460             * @see railo.runtime.type.QueryImpl#_getMetaData()
461             */
462            public synchronized Struct _getMetaData() {
463                    return query._getMetaData();
464            }
465    
466            /**
467             * @see railo.runtime.type.QueryImpl#getMetaDataSimple()
468             */
469            public synchronized Array getMetaDataSimple() {
470                    return query.getMetaDataSimple();
471            }
472    
473            /**
474             * @see railo.runtime.type.QueryImpl#getName()
475             */
476            public String getName() {
477                    return query.getName();
478            }
479    
480            /**
481             * @see railo.runtime.type.QueryImpl#getObject(java.lang.String)
482             */
483            public Object getObject(String columnName) throws SQLException {
484                    return query.getObject(columnName);
485            }
486    
487            /**
488             * @see railo.runtime.type.QueryImpl#getObject(int)
489             */
490            public Object getObject(int columnIndex) throws SQLException {
491                    return query.getObject(columnIndex);
492            }
493    
494            /**
495             * @see railo.runtime.type.QueryImpl#getRecordcount()
496             */
497            public int getRecordcount() {
498                    return query.getRecordcount();
499            }
500    
501            /**
502             * @see railo.runtime.type.QueryImpl#getRowCount()
503             */
504            public int getRowCount() {
505                    return query.getRowCount();
506            }
507    
508            /**
509             * @see railo.runtime.type.QueryImpl#getSql()
510             */
511            public SQL getSql() {
512                    return query.getSql();
513            }
514    
515            /**
516             * @see railo.runtime.type.QueryImpl#getString(int)
517             */
518            public String getString(int columnIndex) throws SQLException {
519                    return query.getString(columnIndex);
520            }
521    
522            /**
523             * @see railo.runtime.type.QueryImpl#getString(java.lang.String)
524             */
525            public String getString(String columnName) throws SQLException {
526                    return query.getString(columnName);
527            }
528    
529            /**
530             * @see railo.runtime.type.QueryImpl#getTypes()
531             */
532            public synchronized int[] getTypes() {
533                    return query.getTypes();
534            }
535    
536            /**
537             * @see railo.runtime.type.QueryImpl#getTypesAsMap()
538             */
539            public synchronized Map getTypesAsMap() {
540                    return query.getTypesAsMap();
541            }
542    
543            /**
544             * @see railo.runtime.type.QueryImpl#go(int)
545             */
546            public boolean go(int index) {
547                    return query.go(index);
548            }
549    
550            /**
551             * @see railo.runtime.type.QueryImpl#go(int, int)
552             */
553            public boolean go(int index, int pid) {
554                    return query.go(index, pid);
555            }
556    
557            /**
558             * @see railo.runtime.type.QueryImpl#isCached()
559             */
560            public boolean isCached() {
561                    return query.isCached();
562            }
563    
564            /**
565             * @see railo.runtime.type.QueryImpl#isEmpty()
566             */
567            public boolean isEmpty() {
568                    return query.isEmpty();
569            }
570    
571            /**
572             * @see railo.runtime.type.QueryImpl#isInitalized()
573             */
574            public boolean isInitalized() {
575                    return query.isInitalized();
576            }
577    
578            /**
579             * @see railo.runtime.type.QueryImpl#iterator()
580             */
581            public Iterator iterator() {
582                    return query.iterator();
583            }
584    
585            /**
586             * @see railo.runtime.type.QueryImpl#keyIterator()
587             */
588            public Iterator keyIterator() {
589                    return query.keyIterator();
590            }
591    
592            /**
593             * @see railo.runtime.type.QueryImpl#keys()
594             */
595            public Collection.Key[] keys() {
596                    return query.keys();
597            }
598    
599            /**
600             * @see railo.runtime.type.QueryImpl#keysAsString()
601             */
602            public String[] keysAsString() {
603                    return query.keysAsString();
604            }
605    
606            /**
607             * @see railo.runtime.type.QueryImpl#next()
608             */
609            public boolean next() {
610                    return query.next();
611            }
612    
613            /**
614             * @see railo.runtime.type.QueryImpl#next(int)
615             */
616            public boolean next(int pid) {
617                    return query.next(pid);
618            }
619    
620            /**
621             * @see railo.runtime.type.QueryImpl#remove(java.lang.String)
622             */
623            public synchronized Object remove(String key) throws PageException {
624                    disconnectCache();
625                    return query.remove(key);
626            }
627    
628            /**
629             * @see railo.runtime.type.QueryImpl#remove(railo.runtime.type.Collection.Key)
630             */
631            public Object remove(Collection.Key key) throws PageException {
632                    disconnectCache();
633                    return query.remove(key);
634            }
635    
636            /**
637             * @see railo.runtime.type.QueryImpl#removeColumn(java.lang.String)
638             */
639            public QueryColumn removeColumn(String key) throws DatabaseException {
640                    disconnectCache();
641                    return query.removeColumn(key);
642            }
643    
644            /**
645             * @see railo.runtime.type.QueryImpl#removeColumn(railo.runtime.type.Collection.Key)
646             */
647            public QueryColumn removeColumn(Collection.Key key) throws DatabaseException {
648                    disconnectCache();
649                    return query.removeColumn(key);
650            }
651    
652            /**
653             * @see railo.runtime.type.QueryImpl#removeColumnEL(java.lang.String)
654             */
655            public synchronized QueryColumn removeColumnEL(String key) {
656                    disconnectCache();
657                    return query.removeColumnEL(key);
658            }
659    
660            /**
661             * @see railo.runtime.type.QueryImpl#removeColumnEL(railo.runtime.type.Collection.Key)
662             */
663            public QueryColumn removeColumnEL(Collection.Key key) {
664                    disconnectCache();
665                    return query.removeColumnEL(key);
666            }
667    
668            /**
669             * @see railo.runtime.type.QueryImpl#removeEL(java.lang.String)
670             */
671            public synchronized Object removeEL(String key) {
672                    disconnectCache();
673                    return query.removeEL(key);
674            }
675    
676            /**
677             * @see railo.runtime.type.QueryImpl#removeEL(railo.runtime.type.Collection.Key)
678             */
679            public Object removeEL(Collection.Key key) {
680                    disconnectCache();
681                    return query.removeEL(key);
682            }
683    
684            /**
685             *
686             * @see railo.runtime.type.QueryImpl#removeRow(int)
687             */
688            public synchronized int removeRow(int row) throws PageException {
689                    disconnectCache();
690                    return query.removeRow(row);
691            }
692    
693            /**
694             * @see railo.runtime.type.QueryImpl#removeRowEL(int)
695             */
696            public int removeRowEL(int row) {
697                    disconnectCache();
698                    return query.removeRowEL(row);
699            }
700    
701            /**
702             * @see railo.runtime.type.QueryImpl#reset()
703             */
704            public void reset() {
705                    query.reset();
706            }
707    
708            /**
709             * @see railo.runtime.type.QueryImpl#reset(int)
710             */
711            public void reset(int pid) {
712                    query.reset(pid);
713            }
714    
715            /**
716             * @see railo.runtime.type.QueryImpl#set(java.lang.String, java.lang.Object)
717             */
718            public Object set(String key, Object value) throws PageException {
719                    disconnectCache();
720                    return query.set(key, value);
721            }
722    
723            /**
724             * @see railo.runtime.type.QueryImpl#set(railo.runtime.type.Collection.Key, java.lang.Object)
725             */
726            public Object set(Collection.Key key, Object value) throws PageException {
727                    disconnectCache();
728                    return query.set(key, value);
729            }
730    
731            /**
732             * @see railo.runtime.type.QueryImpl#set(railo.runtime.PageContext, java.lang.String, java.lang.Object)
733             */
734            public Object set(PageContext pc, String propertyName, Object value) throws PageException {
735                    disconnectCache();
736                    return query.set(pc, propertyName, value);
737            }
738    
739            /**
740             * @see railo.runtime.type.QueryImpl#set(railo.runtime.PageContext, railo.runtime.type.Collection.Key, java.lang.Object)
741             */
742            public Object set(PageContext pc, Collection.Key propertyName, Object value) throws PageException {
743                    disconnectCache();
744                    return query.set(pc, propertyName, value);
745            }
746    
747            /**
748             * @see railo.runtime.type.QueryImpl#setAt(java.lang.String, int, java.lang.Object)
749             */
750            public Object setAt(String key, int row, Object value) throws PageException {
751                    disconnectCache();
752                    return query.setAt(key, row, value);
753            }
754    
755            /**
756             * @see railo.runtime.type.QueryImpl#setAt(railo.runtime.type.Collection.Key, int, java.lang.Object)
757             */
758            public Object setAt(Collection.Key key, int row, Object value) throws PageException {
759                    disconnectCache();
760                    return query.setAt(key, row, value);
761            }
762    
763            /**
764             * @see railo.runtime.type.QueryImpl#setAtEL(java.lang.String, int, java.lang.Object)
765             */
766            public Object setAtEL(String key, int row, Object value) {
767                    disconnectCache();
768                    return query.setAtEL(key, row, value);
769            }
770    
771            /**
772             * @see railo.runtime.type.QueryImpl#setAtEL(railo.runtime.type.Collection.Key, int, java.lang.Object)
773             */
774            public Object setAtEL(Collection.Key key, int row, Object value) {
775                    disconnectCache();
776                    return query.setAtEL(key, row, value);
777            }
778    
779            /**
780             * @see railo.runtime.type.QueryImpl#setCached(boolean)
781             */
782            public void setCached(boolean isCached) {
783                    query.setCached(isCached);
784            }
785    
786            /**
787             * @see railo.runtime.type.QueryImpl#setData(int, int, java.lang.String)
788             */
789            public void setData(int row, int col, String value) throws IndexOutOfBoundsException {
790                    disconnectCache();
791                    query.setData(row, col, value);
792            }
793    
794            /**
795             * @see railo.runtime.type.QueryImpl#setEL(java.lang.String, java.lang.Object)
796             */
797            public Object setEL(String key, Object value) {
798                    disconnectCache();
799                    return query.setEL(key, value);
800            }
801    
802            /**
803             * @see railo.runtime.type.QueryImpl#setEL(railo.runtime.type.Collection.Key, java.lang.Object)
804             */
805            public Object setEL(Collection.Key key, Object value) {
806                    disconnectCache();
807                    return query.setEL(key, value);
808            }
809    
810            /**
811             * @see railo.runtime.type.QueryImpl#setEL(railo.runtime.PageContext, java.lang.String, java.lang.Object)
812             */
813            public Object setEL(PageContext pc, String propertyName, Object value) {
814                    disconnectCache();
815                    return query.setEL(pc, propertyName, value);
816            }
817    
818            /**
819             * @see railo.runtime.type.QueryImpl#setEL(railo.runtime.PageContext, railo.runtime.type.Collection.Key, java.lang.Object)
820             */
821            public Object setEL(PageContext pc, Collection.Key propertyName, Object value) {
822                    disconnectCache();
823                    return query.setEL(pc, propertyName, value);
824            }
825    
826            /**
827             * @see railo.runtime.type.QueryImpl#setExecutionTime(long)
828             */
829            public void setExecutionTime(long exeTime) {
830                    disconnectCache();
831                    query.setExecutionTime(exeTime);
832            }
833    
834    
835            /**
836             * @see railo.runtime.type.QueryImpl#setSql(railo.runtime.db.SQL)
837             */
838            public void setSql(SQL sql) {
839                    disconnectCache();
840                    query.setSql(sql);
841            }
842    
843            /**
844             * @see railo.runtime.type.QueryImpl#size()
845             */
846            public int size() {
847                    return query.size();
848            }
849    
850            /**
851             * @see railo.runtime.type.QueryImpl#sort(java.lang.String)
852             */
853            public void sort(String column) throws PageException {
854                    disconnectCache();
855                    query.sort(column);
856            }
857    
858            /**
859             * @see railo.runtime.type.QueryImpl#sort(railo.runtime.type.Collection.Key)
860             */
861            public void sort(Collection.Key column) throws PageException {
862                    disconnectCache();
863                    query.sort(column);
864            }
865    
866            /**
867             * @see railo.runtime.type.QueryImpl#sort(java.lang.String, int)
868             */
869            public synchronized void sort(String strColumn, int order) throws PageException {
870                    disconnectCache();
871                    query.sort(strColumn, order);
872            }
873    
874            /**
875             * @see railo.runtime.type.QueryImpl#sort(railo.runtime.type.Collection.Key, int)
876             */
877            public synchronized void sort(Collection.Key keyColumn, int order) throws PageException {
878                    disconnectCache();
879                    query.sort(keyColumn, order);
880            }
881    
882            /**
883             * @see railo.runtime.type.QueryImpl#toDumpData(railo.runtime.PageContext, int)
884             */
885            public DumpData toDumpData(PageContext pageContext, int maxlevel, DumpProperties dp) {
886                    return query.toDumpData(pageContext, maxlevel,dp);
887            }
888    
889            /**
890             * @see railo.runtime.type.QueryImpl#toString()
891             */
892            public String toString() {
893                    return query.toString();
894            }
895    
896            public QueryImpl getQuery() {
897                    return query;
898            }
899    
900            /**
901             * @see railo.runtime.type.QueryImpl#cancelRowUpdates()
902             */
903            public void cancelRowUpdates() throws SQLException {
904                    disconnectCache();
905                    query.cancelRowUpdates();
906            }
907    
908            /**
909             * @see railo.runtime.type.QueryImpl#deleteRow()
910             */
911            public void deleteRow() throws SQLException {
912                    disconnectCache();
913                    query.deleteRow();
914            }
915    
916            /**
917             * @see railo.runtime.type.QueryImpl#insertRow()
918             */
919            public void insertRow() throws SQLException {
920                    disconnectCache();
921                    query.insertRow();
922            }
923    
924            /**
925             * @see railo.runtime.type.QueryImpl#rename(railo.runtime.type.Collection.Key, railo.runtime.type.Collection.Key)
926             */
927            public synchronized void rename(Collection.Key columnName, Collection.Key newColumnName)
928                            throws ExpressionException {
929                    disconnectCache();
930                    query.rename(columnName, newColumnName);
931            }
932    
933            /**
934             * @see railo.runtime.type.QueryImpl#rowDeleted()
935             */
936            public boolean rowDeleted() throws SQLException {
937                    return query.rowDeleted();
938            }
939    
940            /**
941             * @see railo.runtime.type.QueryImpl#rowInserted()
942             */
943            public boolean rowInserted() throws SQLException {
944                    return query.rowInserted();
945            }
946    
947            /**
948             * @see railo.runtime.type.QueryImpl#rowUpdated()
949             */
950            public boolean rowUpdated() throws SQLException {
951                    return query.rowUpdated();
952            }
953    
954            /**
955             * @see railo.runtime.type.QueryImpl#setFetchDirection(int)
956             */
957            public void setFetchDirection(int direction) throws SQLException {
958                    disconnectCache();
959                    query.setFetchDirection(direction);
960            }
961    
962            /**
963             * @see railo.runtime.type.QueryImpl#setFetchSize(int)
964             */
965            public void setFetchSize(int rows) throws SQLException {
966                    disconnectCache();
967                    query.setFetchSize(rows);
968            }
969    
970            /**
971             * @see railo.runtime.type.QueryImpl#updateArray(int, java.sql.Array)
972             */
973            public void updateArray(int columnIndex, java.sql.Array x)
974                            throws SQLException {
975                    disconnectCache();
976                    query.updateArray(columnIndex, x);
977            }
978    
979            /**
980             * @see railo.runtime.type.QueryImpl#updateArray(java.lang.String, java.sql.Array)
981             */
982            public void updateArray(String columnName, java.sql.Array x)
983                            throws SQLException {
984                    disconnectCache();
985                    query.updateArray(columnName, x);
986            }
987    
988            /**
989             * @see railo.runtime.type.QueryImpl#updateAsciiStream(int, java.io.InputStream, int)
990             */
991            public void updateAsciiStream(int columnIndex, InputStream x, int length)
992                            throws SQLException {
993                    disconnectCache();
994                    query.updateAsciiStream(columnIndex, x, length);
995            }
996    
997            /**
998             * @see railo.runtime.type.QueryImpl#updateAsciiStream(java.lang.String, java.io.InputStream, int)
999             */
1000            public void updateAsciiStream(String columnName, InputStream x, int length)
1001                            throws SQLException {
1002                    disconnectCache();
1003                    query.updateAsciiStream(columnName, x, length);
1004            }
1005    
1006            /**
1007             * @see railo.runtime.type.QueryImpl#updateBigDecimal(int, java.math.BigDecimal)
1008             */
1009            public void updateBigDecimal(int columnIndex, BigDecimal x)
1010                            throws SQLException {
1011                    disconnectCache();
1012                    query.updateBigDecimal(columnIndex, x);
1013            }
1014    
1015            /**
1016             * @see railo.runtime.type.QueryImpl#updateBigDecimal(java.lang.String, java.math.BigDecimal)
1017             */
1018            public void updateBigDecimal(String columnName, BigDecimal x)
1019                            throws SQLException {
1020                    disconnectCache();
1021                    query.updateBigDecimal(columnName, x);
1022            }
1023    
1024            /**
1025             * @see railo.runtime.type.QueryImpl#updateBinaryStream(int, java.io.InputStream, int)
1026             */
1027            public void updateBinaryStream(int columnIndex, InputStream x, int length)
1028                            throws SQLException {
1029                    disconnectCache();
1030                    query.updateBinaryStream(columnIndex, x, length);
1031            }
1032    
1033            /**
1034             * @see railo.runtime.type.QueryImpl#updateBinaryStream(java.lang.String, java.io.InputStream, int)
1035             */
1036            public void updateBinaryStream(String columnName, InputStream x, int length)
1037                            throws SQLException {
1038                    disconnectCache();
1039                    query.updateBinaryStream(columnName, x, length);
1040            }
1041    
1042            /**
1043             * @see railo.runtime.type.QueryImpl#updateBlob(int, java.sql.Blob)
1044             */
1045            public void updateBlob(int columnIndex, Blob x) throws SQLException {
1046                    disconnectCache();
1047                    query.updateBlob(columnIndex, x);
1048            }
1049    
1050            /**
1051             * @see railo.runtime.type.QueryImpl#updateBlob(java.lang.String, java.sql.Blob)
1052             */
1053            public void updateBlob(String columnName, Blob x) throws SQLException {
1054                    disconnectCache();
1055                    query.updateBlob(columnName, x);
1056            }
1057    
1058            /**
1059             * @see railo.runtime.type.QueryImpl#updateBoolean(int, boolean)
1060             */
1061            public void updateBoolean(int columnIndex, boolean x) throws SQLException {
1062                    disconnectCache();
1063                    query.updateBoolean(columnIndex, x);
1064            }
1065    
1066            /**
1067             * @see railo.runtime.type.QueryImpl#updateBoolean(java.lang.String, boolean)
1068             */
1069            public void updateBoolean(String columnName, boolean x) throws SQLException {
1070                    disconnectCache();
1071                    query.updateBoolean(columnName, x);
1072            }
1073    
1074            /**
1075             * @see railo.runtime.type.QueryImpl#updateByte(int, byte)
1076             */
1077            public void updateByte(int columnIndex, byte x) throws SQLException {
1078                    disconnectCache();
1079                    query.updateByte(columnIndex, x);
1080            }
1081    
1082            /**
1083             * @see railo.runtime.type.QueryImpl#updateByte(java.lang.String, byte)
1084             */
1085            public void updateByte(String columnName, byte x) throws SQLException {
1086                    disconnectCache();
1087                    query.updateByte(columnName, x);
1088            }
1089    
1090            /**
1091             * @see railo.runtime.type.QueryImpl#updateBytes(int, byte[])
1092             */
1093            public void updateBytes(int columnIndex, byte[] x) throws SQLException {
1094                    disconnectCache();
1095                    query.updateBytes(columnIndex, x);
1096            }
1097    
1098            /**
1099             * @see railo.runtime.type.QueryImpl#updateBytes(java.lang.String, byte[])
1100             */
1101            public void updateBytes(String columnName, byte[] x) throws SQLException {
1102                    disconnectCache();
1103                    query.updateBytes(columnName, x);
1104            }
1105    
1106            /**
1107             * @see railo.runtime.type.QueryImpl#updateCharacterStream(int, java.io.Reader, int)
1108             */
1109            public void updateCharacterStream(int columnIndex, Reader reader, int length)
1110                            throws SQLException {
1111                    disconnectCache();
1112                    query.updateCharacterStream(columnIndex, reader, length);
1113            }
1114    
1115            /**
1116             * @see railo.runtime.type.QueryImpl#updateCharacterStream(java.lang.String, java.io.Reader, int)
1117             */
1118            public void updateCharacterStream(String columnName, Reader reader,
1119                            int length) throws SQLException {
1120                    disconnectCache();
1121                    query.updateCharacterStream(columnName, reader, length);
1122            }
1123    
1124            /**
1125             * @see railo.runtime.type.QueryImpl#updateClob(int, java.sql.Clob)
1126             */
1127            public void updateClob(int columnIndex, Clob x) throws SQLException {
1128                    disconnectCache();
1129                    query.updateClob(columnIndex, x);
1130            }
1131    
1132            /**
1133             * @see railo.runtime.type.QueryImpl#updateClob(java.lang.String, java.sql.Clob)
1134             */
1135            public void updateClob(String columnName, Clob x) throws SQLException {
1136                    disconnectCache();
1137                    query.updateClob(columnName, x);
1138            }
1139    
1140            /**
1141             * @see railo.runtime.type.QueryImpl#updateDate(int, java.sql.Date)
1142             */
1143            public void updateDate(int columnIndex, Date x) throws SQLException {
1144                    disconnectCache();
1145                    query.updateDate(columnIndex, x);
1146            }
1147    
1148            /**
1149             * @see railo.runtime.type.QueryImpl#updateDate(java.lang.String, java.sql.Date)
1150             */
1151            public void updateDate(String columnName, Date x) throws SQLException {
1152                    disconnectCache();
1153                    query.updateDate(columnName, x);
1154            }
1155    
1156            /**
1157             * @see railo.runtime.type.QueryImpl#updateDouble(int, double)
1158             */
1159            public void updateDouble(int columnIndex, double x) throws SQLException {
1160                    disconnectCache();
1161                    query.updateDouble(columnIndex, x);
1162            }
1163    
1164            /**
1165             * @see railo.runtime.type.QueryImpl#updateDouble(java.lang.String, double)
1166             */
1167            public void updateDouble(String columnName, double x) throws SQLException {
1168                    disconnectCache();
1169                    query.updateDouble(columnName, x);
1170            }
1171    
1172            /**
1173             * @see railo.runtime.type.QueryImpl#updateFloat(int, float)
1174             */
1175            public void updateFloat(int columnIndex, float x) throws SQLException {
1176                    disconnectCache();
1177                    query.updateFloat(columnIndex, x);
1178            }
1179    
1180            /**
1181             * @see railo.runtime.type.QueryImpl#updateFloat(java.lang.String, float)
1182             */
1183            public void updateFloat(String columnName, float x) throws SQLException {
1184                    disconnectCache();
1185                    query.updateFloat(columnName, x);
1186            }
1187    
1188            /**
1189             * @see railo.runtime.type.QueryImpl#updateInt(int, int)
1190             */
1191            public void updateInt(int columnIndex, int x) throws SQLException {
1192                    disconnectCache();
1193                    query.updateInt(columnIndex, x);
1194            }
1195    
1196            /**
1197             * @see railo.runtime.type.QueryImpl#updateInt(java.lang.String, int)
1198             */
1199            public void updateInt(String columnName, int x) throws SQLException {
1200                    disconnectCache();
1201                    query.updateInt(columnName, x);
1202            }
1203    
1204            /**
1205             * @see railo.runtime.type.QueryImpl#updateLong(int, long)
1206             */
1207            public void updateLong(int columnIndex, long x) throws SQLException {
1208                    disconnectCache();
1209                    query.updateLong(columnIndex, x);
1210            }
1211    
1212            /**
1213             * @see railo.runtime.type.QueryImpl#updateLong(java.lang.String, long)
1214             */
1215            public void updateLong(String columnName, long x) throws SQLException {
1216                    disconnectCache();
1217                    query.updateLong(columnName, x);
1218            }
1219    
1220            /**
1221             * @see railo.runtime.type.QueryImpl#updateNull(int)
1222             */
1223            public void updateNull(int columnIndex) throws SQLException {
1224                    disconnectCache();
1225                    query.updateNull(columnIndex);
1226            }
1227    
1228            /**
1229             * @see railo.runtime.type.QueryImpl#updateNull(java.lang.String)
1230             */
1231            public void updateNull(String columnName) throws SQLException {
1232                    disconnectCache();
1233                    query.updateNull(columnName);
1234            }
1235    
1236            /**
1237             * @see railo.runtime.type.QueryImpl#updateObject(int, java.lang.Object)
1238             */
1239            public void updateObject(int columnIndex, Object x) throws SQLException {
1240                    disconnectCache();
1241                    query.updateObject(columnIndex, x);
1242            }
1243    
1244            /**
1245             * @see railo.runtime.type.QueryImpl#updateObject(java.lang.String, java.lang.Object)
1246             */
1247            public void updateObject(String columnName, Object x) throws SQLException {
1248                    disconnectCache();
1249                    query.updateObject(columnName, x);
1250            }
1251    
1252            /**
1253             * @see railo.runtime.type.QueryImpl#updateObject(int, java.lang.Object, int)
1254             */
1255            public void updateObject(int columnIndex, Object x, int scale)
1256                            throws SQLException {
1257                    disconnectCache();
1258                    query.updateObject(columnIndex, x, scale);
1259            }
1260    
1261            /**
1262             * @see railo.runtime.type.QueryImpl#updateObject(java.lang.String, java.lang.Object, int)
1263             */
1264            public void updateObject(String columnName, Object x, int scale)
1265                            throws SQLException {
1266                    disconnectCache();
1267                    query.updateObject(columnName, x, scale);
1268            }
1269    
1270            /**
1271             * @see railo.runtime.type.QueryImpl#updateRef(int, java.sql.Ref)
1272             */
1273            public void updateRef(int columnIndex, Ref x) throws SQLException {
1274                    disconnectCache();
1275                    query.updateRef(columnIndex, x);
1276            }
1277    
1278            /**
1279             * @see railo.runtime.type.QueryImpl#updateRef(java.lang.String, java.sql.Ref)
1280             */
1281            public void updateRef(String columnName, Ref x) throws SQLException {
1282                    disconnectCache();
1283                    query.updateRef(columnName, x);
1284            }
1285    
1286            /**
1287             * @see railo.runtime.type.QueryImpl#updateRow()
1288             */
1289            public void updateRow() throws SQLException {
1290                    disconnectCache();
1291                    query.updateRow();
1292            }
1293    
1294            /**
1295             * @see railo.runtime.type.QueryImpl#updateShort(int, short)
1296             */
1297            public void updateShort(int columnIndex, short x) throws SQLException {
1298                    disconnectCache();
1299                    query.updateShort(columnIndex, x);
1300            }
1301    
1302            /**
1303             * @see railo.runtime.type.QueryImpl#updateShort(java.lang.String, short)
1304             */
1305            public void updateShort(String columnName, short x) throws SQLException {
1306                    disconnectCache();
1307                    query.updateShort(columnName, x);
1308            }
1309    
1310            /**
1311             * @see railo.runtime.type.QueryImpl#updateString(int, java.lang.String)
1312             */
1313            public void updateString(int columnIndex, String x) throws SQLException {
1314                    disconnectCache();
1315                    query.updateString(columnIndex, x);
1316            }
1317    
1318            /**
1319             * @see railo.runtime.type.QueryImpl#updateString(java.lang.String, java.lang.String)
1320             */
1321            public void updateString(String columnName, String x) throws SQLException {
1322                    disconnectCache();
1323                    query.updateString(columnName, x);
1324            }
1325    
1326            /**
1327             * @see railo.runtime.type.QueryImpl#updateTime(int, java.sql.Time)
1328             */
1329            public void updateTime(int columnIndex, Time x) throws SQLException {
1330                    disconnectCache();
1331                    query.updateTime(columnIndex, x);
1332            }
1333    
1334            /**
1335             * @see railo.runtime.type.QueryImpl#updateTime(java.lang.String, java.sql.Time)
1336             */
1337            public void updateTime(String columnName, Time x) throws SQLException {
1338                    disconnectCache();
1339                    query.updateTime(columnName, x);
1340            }
1341    
1342            /**
1343             * @see railo.runtime.type.QueryImpl#updateTimestamp(int, java.sql.Timestamp)
1344             */
1345            public void updateTimestamp(int columnIndex, Timestamp x)
1346                            throws SQLException {
1347                    disconnectCache();
1348                    query.updateTimestamp(columnIndex, x);
1349            }
1350    
1351            /**
1352             * @see railo.runtime.type.QueryImpl#updateTimestamp(java.lang.String, java.sql.Timestamp)
1353             */
1354            public void updateTimestamp(String columnName, Timestamp x)
1355                            throws SQLException {
1356                    disconnectCache();
1357                    query.updateTimestamp(columnName, x);
1358            }
1359    
1360            /**
1361             * @see railo.runtime.type.QueryImpl#wasNull()
1362             */
1363            public boolean wasNull() {
1364                    return query.wasNull();
1365            }
1366            
1367    
1368            /**
1369             * @see railo.runtime.type.QueryImpl#absolute(int)
1370             */
1371            public boolean absolute(int row) throws SQLException {
1372                    return query.absolute(row);
1373            }
1374    
1375            /**
1376             * @see railo.runtime.type.QueryImpl#afterLast()
1377             */
1378            public void afterLast() throws SQLException {
1379                    query.afterLast();
1380            }
1381    
1382            /**
1383             * @see railo.runtime.type.QueryImpl#beforeFirst()
1384             */
1385            public void beforeFirst() throws SQLException {
1386                    query.beforeFirst();
1387            }
1388    
1389            /**
1390             * @see railo.runtime.type.QueryImpl#clearWarnings()
1391             */
1392            public void clearWarnings() throws SQLException {
1393                    disconnectCache();
1394                    query.clearWarnings();
1395            }
1396    
1397            /**
1398             * @see railo.runtime.type.QueryImpl#close()
1399             */
1400            public void close() throws SQLException {
1401                    disconnectCache();
1402                    query.close();
1403            }
1404    
1405            /**
1406             * @see railo.runtime.type.QueryImpl#findColumn(java.lang.String)
1407             */
1408            public int findColumn(String columnName) throws SQLException {
1409                    return query.findColumn(columnName);
1410            }
1411    
1412            /**
1413             * @see railo.runtime.type.QueryImpl#first()
1414             */
1415            public boolean first() throws SQLException {
1416                    return query.first();
1417            }
1418    
1419            /**
1420             * @see railo.runtime.type.QueryImpl#getArray(int)
1421             */
1422            public java.sql.Array getArray(int i) throws SQLException {
1423                    return query.getArray(i);
1424            }
1425    
1426            /**
1427             * @see railo.runtime.type.QueryImpl#getArray(java.lang.String)
1428             */
1429            public java.sql.Array getArray(String colName) throws SQLException {
1430                    return query.getArray(colName);
1431            }
1432    
1433            /**
1434             * @see railo.runtime.type.QueryImpl#getAsciiStream(int)
1435             */
1436            public InputStream getAsciiStream(int columnIndex) throws SQLException {
1437                    return query.getAsciiStream(columnIndex);
1438            }
1439    
1440            /**
1441             * @see railo.runtime.type.QueryImpl#getAsciiStream(java.lang.String)
1442             */
1443            public InputStream getAsciiStream(String columnName) throws SQLException {
1444                    return query.getAsciiStream(columnName);
1445            }
1446    
1447            /**
1448             * @see railo.runtime.type.QueryImpl#getBigDecimal(int, int)
1449             */
1450            public BigDecimal getBigDecimal(int columnIndex, int scale)
1451                            throws SQLException {
1452                    return query.getBigDecimal(columnIndex, scale);
1453            }
1454    
1455            /**
1456             * @see railo.runtime.type.QueryImpl#getBigDecimal(int)
1457             */
1458            public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
1459                    return query.getBigDecimal(columnIndex);
1460            }
1461    
1462            /**
1463             * @see railo.runtime.type.QueryImpl#getBigDecimal(java.lang.String, int)
1464             */
1465            public BigDecimal getBigDecimal(String columnName, int scale)
1466                            throws SQLException {
1467                    return query.getBigDecimal(columnName, scale);
1468            }
1469    
1470            /**
1471             * @see railo.runtime.type.QueryImpl#getBigDecimal(java.lang.String)
1472             */
1473            public BigDecimal getBigDecimal(String columnName) throws SQLException {
1474                    return query.getBigDecimal(columnName);
1475            }
1476    
1477            /**
1478             * @see railo.runtime.type.QueryImpl#getBinaryStream(int)
1479             */
1480            public InputStream getBinaryStream(int columnIndex) throws SQLException {
1481                    return query.getBinaryStream(columnIndex);
1482            }
1483    
1484            /**
1485             * @see railo.runtime.type.QueryImpl#getBinaryStream(java.lang.String)
1486             */
1487            public InputStream getBinaryStream(String columnName) throws SQLException {
1488                    return query.getBinaryStream(columnName);
1489            }
1490    
1491            /**
1492             * @see railo.runtime.type.QueryImpl#getBlob(int)
1493             */
1494            public Blob getBlob(int i) throws SQLException {
1495                    return query.getBlob(i);
1496            }
1497    
1498            /**
1499             * @see railo.runtime.type.QueryImpl#getBlob(java.lang.String)
1500             */
1501            public Blob getBlob(String colName) throws SQLException {
1502                    return query.getBlob(colName);
1503            }
1504    
1505            /**
1506             * @see railo.runtime.type.QueryImpl#getByte(int)
1507             */
1508            public byte getByte(int columnIndex) throws SQLException {
1509                    // TODO Auto-generated method stub
1510                    return query.getByte(columnIndex);
1511            }
1512    
1513            /**
1514             * @see railo.runtime.type.QueryImpl#getByte(java.lang.String)
1515             */
1516            public byte getByte(String columnName) throws SQLException {
1517                    // TODO Auto-generated method stub
1518                    return query.getByte(columnName);
1519            }
1520    
1521            /**
1522             * @see railo.runtime.type.QueryImpl#getBytes(int)
1523             */
1524            public byte[] getBytes(int columnIndex) throws SQLException {
1525                    // TODO Auto-generated method stub
1526                    return query.getBytes(columnIndex);
1527            }
1528    
1529            /**
1530             * @see railo.runtime.type.QueryImpl#getBytes(java.lang.String)
1531             */
1532            public byte[] getBytes(String columnName) throws SQLException {
1533                    // TODO Auto-generated method stub
1534                    return query.getBytes(columnName);
1535            }
1536    
1537            /**
1538             * @see railo.runtime.type.QueryImpl#getCharacterStream(int)
1539             */
1540            public Reader getCharacterStream(int columnIndex) throws SQLException {
1541                    // TODO Auto-generated method stub
1542                    return query.getCharacterStream(columnIndex);
1543            }
1544    
1545            /**
1546             * @see railo.runtime.type.QueryImpl#getCharacterStream(java.lang.String)
1547             */
1548            public Reader getCharacterStream(String columnName) throws SQLException {
1549                    // TODO Auto-generated method stub
1550                    return query.getCharacterStream(columnName);
1551            }
1552    
1553            /**
1554             * @see railo.runtime.type.QueryImpl#getClob(int)
1555             */
1556            public Clob getClob(int i) throws SQLException {
1557                    // TODO Auto-generated method stub
1558                    return query.getClob(i);
1559            }
1560    
1561            /**
1562             * @see railo.runtime.type.QueryImpl#getClob(java.lang.String)
1563             */
1564            public Clob getClob(String colName) throws SQLException {
1565                    // TODO Auto-generated method stub
1566                    return query.getClob(colName);
1567            }
1568    
1569            /**
1570             * @see railo.runtime.type.QueryImpl#getColumnlist(boolean)
1571             */
1572            public String getColumnlist(boolean upperCase) {
1573                    // TODO Auto-generated method stub
1574                    return query.getColumnlist(upperCase);
1575            }
1576    
1577            /**
1578             * @see railo.runtime.type.QueryImpl#getColumnName(int)
1579             */
1580            public Collection.Key getColumnName(int columnIndex) {
1581                    // TODO Auto-generated method stub
1582                    return query.getColumnName(columnIndex);
1583            }
1584    
1585            /**
1586             * @see railo.runtime.type.QueryImpl#getColumnNames()
1587             */
1588            public Collection.Key[] getColumnNames() {
1589                    // TODO Auto-generated method stub
1590                    return query.getColumnNames();
1591            }
1592    
1593            /**
1594             * @see railo.runtime.type.QueryImpl#getColumnNamesAsString()
1595             */
1596            public String[] getColumnNamesAsString() {
1597                    // TODO Auto-generated method stub
1598                    return query.getColumnNamesAsString();
1599            }
1600    
1601            /**
1602             * @see railo.runtime.type.QueryImpl#getConcurrency()
1603             */
1604            public int getConcurrency() throws SQLException {
1605                    // TODO Auto-generated method stub
1606                    return query.getConcurrency();
1607            }
1608    
1609            /**
1610             * @see railo.runtime.type.QueryImpl#getCursorName()
1611             */
1612            public String getCursorName() throws SQLException {
1613                    // TODO Auto-generated method stub
1614                    return query.getCursorName();
1615            }
1616    
1617            /**
1618             * @see railo.runtime.type.QueryImpl#getDate(int, java.util.Calendar)
1619             */
1620            public Date getDate(int columnIndex, Calendar cal) throws SQLException {
1621                    // TODO Auto-generated method stub
1622                    return query.getDate(columnIndex, cal);
1623            }
1624    
1625            /**
1626             * @see railo.runtime.type.QueryImpl#getDate(int)
1627             */
1628            public Date getDate(int columnIndex) throws SQLException {
1629                    // TODO Auto-generated method stub
1630                    return query.getDate(columnIndex);
1631            }
1632    
1633            /**
1634             * @see railo.runtime.type.QueryImpl#getDate(java.lang.String, java.util.Calendar)
1635             */
1636            public Date getDate(String columnName, Calendar cal) throws SQLException {
1637                    // TODO Auto-generated method stub
1638                    return query.getDate(columnName, cal);
1639            }
1640    
1641            /**
1642             * @see railo.runtime.type.QueryImpl#getDate(java.lang.String)
1643             */
1644            public Date getDate(String columnName) throws SQLException {
1645                    // TODO Auto-generated method stub
1646                    return query.getDate(columnName);
1647            }
1648    
1649            /**
1650             * @see railo.runtime.type.QueryImpl#getDouble(int)
1651             */
1652            public double getDouble(int columnIndex) throws SQLException {
1653                    // TODO Auto-generated method stub
1654                    return query.getDouble(columnIndex);
1655            }
1656    
1657            /**
1658             * @see railo.runtime.type.QueryImpl#getDouble(java.lang.String)
1659             */
1660            public double getDouble(String columnName) throws SQLException {
1661                    // TODO Auto-generated method stub
1662                    return query.getDouble(columnName);
1663            }
1664    
1665            /**
1666             * @see railo.runtime.type.QueryImpl#getFetchDirection()
1667             */
1668            public int getFetchDirection() throws SQLException {
1669                    // TODO Auto-generated method stub
1670                    return query.getFetchDirection();
1671            }
1672    
1673            /**
1674             * @see railo.runtime.type.QueryImpl#getFetchSize()
1675             */
1676            public int getFetchSize() throws SQLException {
1677                    // TODO Auto-generated method stub
1678                    return query.getFetchSize();
1679            }
1680    
1681            /**
1682             * @see railo.runtime.type.QueryImpl#getFloat(int)
1683             */
1684            public float getFloat(int columnIndex) throws SQLException {
1685                    // TODO Auto-generated method stub
1686                    return query.getFloat(columnIndex);
1687            }
1688    
1689            /**
1690             * @see railo.runtime.type.QueryImpl#getFloat(java.lang.String)
1691             */
1692            public float getFloat(String columnName) throws SQLException {
1693                    // TODO Auto-generated method stub
1694                    return query.getFloat(columnName);
1695            }
1696    
1697            /**
1698             * @see railo.runtime.type.QueryImpl#getGeneratedKeys()
1699             */
1700            public Query getGeneratedKeys() {
1701                    // TODO Auto-generated method stub
1702                    return query.getGeneratedKeys();
1703            }
1704    
1705            /**
1706             * @see railo.runtime.type.QueryImpl#getInt(int)
1707             */
1708            public int getInt(int columnIndex) throws SQLException {
1709                    // TODO Auto-generated method stub
1710                    return query.getInt(columnIndex);
1711            }
1712    
1713            /**
1714             * @see railo.runtime.type.QueryImpl#getInt(java.lang.String)
1715             */
1716            public int getInt(String columnName) throws SQLException {
1717                    // TODO Auto-generated method stub
1718                    return query.getInt(columnName);
1719            }
1720    
1721            /**
1722             * @see railo.runtime.type.QueryImpl#getLong(int)
1723             */
1724            public long getLong(int columnIndex) throws SQLException {
1725                    // TODO Auto-generated method stub
1726                    return query.getLong(columnIndex);
1727            }
1728    
1729            /**
1730             * @see railo.runtime.type.QueryImpl#getLong(java.lang.String)
1731             */
1732            public long getLong(String columnName) throws SQLException {
1733                    // TODO Auto-generated method stub
1734                    return query.getLong(columnName);
1735            }
1736    
1737            /**
1738             * @see railo.runtime.type.QueryImpl#getMetaData()
1739             */
1740            public ResultSetMetaData getMetaData() throws SQLException {
1741                    // TODO Auto-generated method stub
1742                    return query.getMetaData();
1743            }
1744    
1745            /**
1746             * @see railo.runtime.type.QueryImpl#getObject(int, java.util.Map)
1747             */
1748            public Object getObject(int i, Map map) throws SQLException {
1749                    // TODO Auto-generated method stub
1750                    return query.getObject(i, map);
1751            }
1752    
1753            /**
1754             * @see railo.runtime.type.QueryImpl#getObject(java.lang.String, java.util.Map)
1755             */
1756            public Object getObject(String colName, Map map) throws SQLException {
1757                    // TODO Auto-generated method stub
1758                    return query.getObject(colName, map);
1759            }
1760    
1761            /**
1762             * @see railo.runtime.type.QueryImpl#getRef(int)
1763             */
1764            public Ref getRef(int i) throws SQLException {
1765                    // TODO Auto-generated method stub
1766                    return query.getRef(i);
1767            }
1768    
1769            /**
1770             * @see railo.runtime.type.QueryImpl#getRef(java.lang.String)
1771             */
1772            public Ref getRef(String colName) throws SQLException {
1773                    // TODO Auto-generated method stub
1774                    return query.getRef(colName);
1775            }
1776    
1777            /**
1778             * @see railo.runtime.type.QueryImpl#getRow()
1779             */
1780            public int getRow() throws SQLException {
1781                    // TODO Auto-generated method stub
1782                    return query.getRow();
1783            }
1784    
1785            /**
1786             * @see railo.runtime.type.QueryImpl#getShort(int)
1787             */
1788            public short getShort(int columnIndex) throws SQLException {
1789                    // TODO Auto-generated method stub
1790                    return query.getShort(columnIndex);
1791            }
1792    
1793            /**
1794             * @see railo.runtime.type.QueryImpl#getShort(java.lang.String)
1795             */
1796            public short getShort(String columnName) throws SQLException {
1797                    // TODO Auto-generated method stub
1798                    return query.getShort(columnName);
1799            }
1800    
1801            /**
1802             * @see railo.runtime.type.QueryImpl#getStatement()
1803             */
1804            public Statement getStatement() throws SQLException {
1805                    // TODO Auto-generated method stub
1806                    return query.getStatement();
1807            }
1808    
1809            /**
1810             * @see railo.runtime.type.QueryImpl#getTime(int, java.util.Calendar)
1811             */
1812            public Time getTime(int columnIndex, Calendar cal) throws SQLException {
1813                    // TODO Auto-generated method stub
1814                    return query.getTime(columnIndex, cal);
1815            }
1816    
1817            /**
1818             * @see railo.runtime.type.QueryImpl#getTime(int)
1819             */
1820            public Time getTime(int columnIndex) throws SQLException {
1821                    // TODO Auto-generated method stub
1822                    return query.getTime(columnIndex);
1823            }
1824    
1825            /**
1826             * @see railo.runtime.type.QueryImpl#getTime(java.lang.String, java.util.Calendar)
1827             */
1828            public Time getTime(String columnName, Calendar cal) throws SQLException {
1829                    // TODO Auto-generated method stub
1830                    return query.getTime(columnName, cal);
1831            }
1832    
1833            /**
1834             * @see railo.runtime.type.QueryImpl#getTime(java.lang.String)
1835             */
1836            public Time getTime(String columnName) throws SQLException {
1837                    // TODO Auto-generated method stub
1838                    return query.getTime(columnName);
1839            }
1840    
1841            /**
1842             * @see railo.runtime.type.QueryImpl#getTimestamp(int, java.util.Calendar)
1843             */
1844            public Timestamp getTimestamp(int columnIndex, Calendar cal)
1845                            throws SQLException {
1846                    // TODO Auto-generated method stub
1847                    return query.getTimestamp(columnIndex, cal);
1848            }
1849    
1850            /**
1851             * @see railo.runtime.type.QueryImpl#getTimestamp(int)
1852             */
1853            public Timestamp getTimestamp(int columnIndex) throws SQLException {
1854                    // TODO Auto-generated method stub
1855                    return query.getTimestamp(columnIndex);
1856            }
1857    
1858            /**
1859             * @see railo.runtime.type.QueryImpl#getTimestamp(java.lang.String, java.util.Calendar)
1860             */
1861            public Timestamp getTimestamp(String columnName, Calendar cal)
1862                            throws SQLException {
1863                    // TODO Auto-generated method stub
1864                    return query.getTimestamp(columnName, cal);
1865            }
1866    
1867            /**
1868             * @see railo.runtime.type.QueryImpl#getTimestamp(java.lang.String)
1869             */
1870            public Timestamp getTimestamp(String columnName) throws SQLException {
1871                    // TODO Auto-generated method stub
1872                    return query.getTimestamp(columnName);
1873            }
1874    
1875            /**
1876             * @see railo.runtime.type.QueryImpl#getType()
1877             */
1878            public int getType() throws SQLException {
1879                    // TODO Auto-generated method stub
1880                    return query.getType();
1881            }
1882    
1883            /**
1884             * @see railo.runtime.type.QueryImpl#getUnicodeStream(int)
1885             */
1886            public InputStream getUnicodeStream(int columnIndex) throws SQLException {
1887                    // TODO Auto-generated method stub
1888                    return query.getUnicodeStream(columnIndex);
1889            }
1890    
1891            /**
1892             * @see railo.runtime.type.QueryImpl#getUnicodeStream(java.lang.String)
1893             */
1894            public InputStream getUnicodeStream(String columnName) throws SQLException {
1895                    // TODO Auto-generated method stub
1896                    return query.getUnicodeStream(columnName);
1897            }
1898    
1899            /**
1900             * @see railo.runtime.type.QueryImpl#getUpdateCount()
1901             */
1902            public int getUpdateCount() {
1903                    // TODO Auto-generated method stub
1904                    return query.getUpdateCount();
1905            }
1906    
1907            /**
1908             * @see railo.runtime.type.QueryImpl#getURL(int)
1909             */
1910            public URL getURL(int columnIndex) throws SQLException {
1911                    // TODO Auto-generated method stub
1912                    return query.getURL(columnIndex);
1913            }
1914    
1915            /**
1916             * @see railo.runtime.type.QueryImpl#getURL(java.lang.String)
1917             */
1918            public URL getURL(String columnName) throws SQLException {
1919                    // TODO Auto-generated method stub
1920                    return query.getURL(columnName);
1921            }
1922    
1923            /**
1924             * @see railo.runtime.type.QueryImpl#getWarnings()
1925             */
1926            public SQLWarning getWarnings() throws SQLException {
1927                    // TODO Auto-generated method stub
1928                    return query.getWarnings();
1929            }
1930    
1931            /**
1932             * @see railo.runtime.type.QueryImpl#isAfterLast()
1933             */
1934            public boolean isAfterLast() throws SQLException {
1935                    // TODO Auto-generated method stub
1936                    return query.isAfterLast();
1937            }
1938    
1939            /**
1940             * @see railo.runtime.type.QueryImpl#isBeforeFirst()
1941             */
1942            public boolean isBeforeFirst() throws SQLException {
1943                    // TODO Auto-generated method stub
1944                    return query.isBeforeFirst();
1945            }
1946    
1947            /**
1948             * @see railo.runtime.type.QueryImpl#isFirst()
1949             */
1950            public boolean isFirst() throws SQLException {
1951                    // TODO Auto-generated method stub
1952                    return query.isFirst();
1953            }
1954    
1955            /**
1956             * @see railo.runtime.type.QueryImpl#isLast()
1957             */
1958            public boolean isLast() throws SQLException {
1959                    // TODO Auto-generated method stub
1960                    return query.isLast();
1961            }
1962    
1963            /**
1964             * @see railo.runtime.type.QueryImpl#last()
1965             */
1966            public boolean last() throws SQLException {
1967                    // TODO Auto-generated method stub
1968                    return query.last();
1969            }
1970    
1971            /**
1972             * @see railo.runtime.type.QueryImpl#moveToCurrentRow()
1973             */
1974            public void moveToCurrentRow() throws SQLException {
1975                    // TODO Auto-generated method stub
1976                    query.moveToCurrentRow();
1977            }
1978    
1979            /**
1980             * @see railo.runtime.type.QueryImpl#moveToInsertRow()
1981             */
1982            public void moveToInsertRow() throws SQLException {
1983                    // TODO Auto-generated method stub
1984                    query.moveToInsertRow();
1985            }
1986    
1987            /**
1988             * @see railo.runtime.type.QueryImpl#previous()
1989             */
1990            public boolean previous() {
1991                    // TODO Auto-generated method stub
1992                    return query.previous();
1993            }
1994    
1995            /**
1996             * @see railo.runtime.type.QueryImpl#previous(int)
1997             */
1998            public boolean previous(int pid) {
1999                    // TODO Auto-generated method stub
2000                    return query.previous(pid);
2001            }
2002    
2003            /**
2004             * @see railo.runtime.type.QueryImpl#refreshRow()
2005             */
2006            public void refreshRow() throws SQLException {
2007                    // TODO Auto-generated method stub
2008                    query.refreshRow();
2009            }
2010    
2011            /**
2012             * @see railo.runtime.type.QueryImpl#relative(int)
2013             */
2014            public boolean relative(int rows) throws SQLException {
2015                    // TODO Auto-generated method stub
2016                    return query.relative(rows);
2017            }
2018    
2019            /**
2020             * @see railo.runtime.type.QueryImpl#setColumnNames(railo.runtime.type.Collection.Key[])
2021             */
2022            public void setColumnNames(Collection.Key[] trg) throws PageException {
2023                    // TODO Auto-generated method stub
2024                    query.setColumnNames(trg);
2025            }
2026    
2027            /**
2028             * @see railo.runtime.type.QueryImpl#valueIterator()
2029             */
2030            public Iterator valueIterator() {
2031                    // TODO Auto-generated method stub
2032                    return query.valueIterator();
2033            }
2034    
2035    }