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    import java.util.Map.Entry;
022    
023    import railo.runtime.PageContext;
024    import railo.runtime.db.SQL;
025    import railo.runtime.dump.DumpData;
026    import railo.runtime.dump.DumpProperties;
027    import railo.runtime.exp.DatabaseException;
028    import railo.runtime.exp.ExpressionException;
029    import railo.runtime.exp.PageException;
030    import railo.runtime.type.Array;
031    import railo.runtime.type.Collection;
032    import railo.runtime.type.KeyImpl;
033    import railo.runtime.type.Query;
034    import railo.runtime.type.QueryColumn;
035    import railo.runtime.type.QueryImpl;
036    import railo.runtime.type.Struct;
037    import railo.runtime.type.dt.DateTime;
038    
039    public class QueryCacheQuery extends QueryImpl {
040    
041            private QueryImpl query;
042            private boolean isCloned=false;
043            private Map _columns=new HashMap();
044    
045            public QueryCacheQuery(QueryImpl query) throws DatabaseException {
046                    super(query.keys(),0,query.getName());
047                    this.query=query;
048            }
049    
050            protected void disconnectCache() {
051                    if(isCloned) return;
052                    this.query=query.cloneQuery(true);
053                    isCloned=true;
054            }
055    
056            @Override
057            public boolean addColumn(String columnName, Array content) throws DatabaseException {
058                    disconnectCache();
059                    return query.addColumn(columnName, content);
060            }
061    
062            @Override
063            public boolean addColumn(Collection.Key columnName, Array content) throws PageException {
064                    disconnectCache();
065                    return query.addColumn(columnName, content);
066            }
067    
068            @Override
069            public synchronized boolean addColumn(String columnName, Array content, int type) throws DatabaseException {
070                    disconnectCache();
071                    return query.addColumn(columnName, content, type);
072            }
073    
074            @Override
075            public boolean addColumn(Collection.Key columnName, Array content, int type) throws DatabaseException {
076                    disconnectCache();
077                    return query.addColumn(columnName, content, type);
078            }
079    
080            @Override
081            public synchronized boolean addRow(int count) {
082                    disconnectCache();
083                    return query.addRow(count);
084            }
085    
086            @Override
087            public int addRow() {
088                    disconnectCache();
089                    return query.addRow();
090            }
091    
092            @Override
093            public Object call(PageContext pc, Collection.Key methodName, Object[] arguments) throws PageException {
094                    return query.call(pc, methodName, arguments);
095            }
096    
097            @Override
098            public Object callWithNamedValues(PageContext pc, Collection.Key methodName, Struct args) throws PageException {
099                    return query.callWithNamedValues(pc, methodName, args);
100            }
101    
102            @Override
103            public boolean castToBooleanValue() throws ExpressionException {
104                    return query.castToBooleanValue();
105            }
106        
107        @Override
108        public Boolean castToBoolean(Boolean defaultValue) {
109            return query.castToBoolean(defaultValue);
110        }
111    
112            @Override
113            public DateTime castToDateTime() throws ExpressionException {
114                    return query.castToDateTime();
115            }
116        
117        @Override
118        public DateTime castToDateTime(DateTime defaultValue) {
119            return query.castToDateTime(defaultValue);
120        }
121    
122            @Override
123            public double castToDoubleValue() throws ExpressionException {
124                    return query.castToDoubleValue();
125            }
126        
127        @Override
128        public double castToDoubleValue(double defaultValue) {
129            return query.castToDoubleValue(defaultValue);
130        }
131    
132            @Override
133            public String castToString() throws ExpressionException {
134                    return query.castToString();
135            }
136            
137            @Override
138            public String castToString(String defaultValue) {
139                    return query.castToString(defaultValue);
140            }
141    
142            @Override
143            public void clear() {
144                    disconnectCache();
145                    query.clear();
146            }
147    
148            @Override
149            public Object clone() {
150                    return query.clone();
151            }
152    
153            @Override
154            public QueryImpl cloneQuery(boolean deepCopy) {
155                    return query.cloneQuery(deepCopy);
156            }
157    
158            @Override
159            public int compareTo(boolean b) throws ExpressionException {
160                    return query.compareTo(b);
161            }
162    
163            @Override
164            public int compareTo(DateTime dt) throws PageException {
165                    return query.compareTo(dt);
166            }
167    
168            @Override
169            public int compareTo(double d) throws PageException {
170                    return query.compareTo(d);
171            }
172    
173            @Override
174            public int compareTo(String str) throws PageException {
175                    return query.compareTo(str);
176            }
177    
178            @Override
179            public boolean containsKey(String key) {
180                    return query.containsKey(key);
181            }
182    
183            @Override
184            public boolean containsKey(Collection.Key key) {
185                    return query.containsKey(key);
186            }
187    
188            @Override
189            public synchronized boolean cutRowsTo(int maxrows) {
190                    disconnectCache();
191                    return query.cutRowsTo(maxrows);
192            }
193    
194            @Override
195            public Collection duplicate(boolean deepCopy) {
196                    return query.duplicate(deepCopy);
197            }
198    
199            @Override
200            public int executionTime() {
201                    return query.executionTime();
202            }
203    
204            @Override
205            public Object get(String key, Object defaultValue) {
206                    return query.get(key, defaultValue);
207            }
208    
209            @Override
210            public Object get(Collection.Key key, Object defaultValue) {
211                    return query.get(key, defaultValue);
212            }
213    
214            @Override
215            public Object get(String key) throws PageException {
216                    return query.get(key);
217            }
218    
219            @Override
220            public Object get(Collection.Key key) throws PageException {
221                    return query.get(key);
222            }
223    
224            @Override
225            public Object get(PageContext pc, Collection.Key key, Object defaultValue) {
226                    return query.get(pc, key, defaultValue);
227            }
228    
229            @Override
230            public Object get(PageContext pc, Collection.Key key) throws PageException {
231                    return query.get(pc, key);
232            }
233    
234            @Override
235            public Object getAt(String key, int row, Object defaultValue) {
236                    return query.getAt(key, row, defaultValue);
237            }
238    
239            @Override
240            public Object getAt(Collection.Key key, int row, Object defaultValue) {
241                    return query.getAt(key, row, defaultValue);
242            }
243    
244            @Override
245            public Object getAt(String key, int row) throws PageException {
246                    return query.getAt(key, row);
247            }
248    
249            @Override
250            public Object getAt(Collection.Key key, int row) throws PageException {
251                    return query.getAt(key, row);
252            }
253    
254            @Override
255            public boolean getBoolean(int columnIndex) throws SQLException {
256                    return query.getBoolean(columnIndex);
257            }
258    
259            @Override
260            public boolean getBoolean(String columnName) throws SQLException {
261                    return query.getBoolean(columnName);
262            }
263    
264            @Override
265            public QueryColumn getColumn(String key) throws DatabaseException {
266                    return getColumn(KeyImpl.getInstance(key));
267            }
268    
269            @Override
270            public QueryColumn getColumn(Collection.Key key) throws DatabaseException {
271                    if(!isCloned) {
272                            QueryColumn column = (QueryColumn) _columns.get(key);
273                            if(column==null) {
274                                    column=QueryCacheQueryColumn.getColumn(this,key);
275                                    _columns.put(key, column);
276                            }
277                            return column;
278                    }
279                    //disconnectCache();
280                    return query.getColumn(key);
281            }
282    
283            @Override
284            public QueryColumn getColumn(String key, QueryColumn defaultValue) {
285                    return getColumn(KeyImpl.getInstance(key),defaultValue);
286            }
287    
288            @Override
289            public QueryColumn getColumn(Collection.Key key, QueryColumn defaultValue) {
290                    if(!isCloned) {
291                            QueryColumn column = (QueryColumn) _columns.get(key);
292                            if(column==null) {
293                                    column=QueryCacheQueryColumn.getColumn(this,key,defaultValue);
294                                    if(column!=defaultValue)_columns.put(key, column);
295                            }
296                            return column;
297                    }
298                    //disconnectCache();
299                    return query.getColumn(key, defaultValue);
300            }
301    
302            @Override
303            public int getColumnIndex(String coulmnName) {
304                    return query.getColumnIndex(coulmnName);
305            }
306    
307            @Override
308            public String getColumnlist() {
309                    return query.getColumnlist();
310            }
311    
312            @Override
313            public String[] getColumns() {
314                    return query.getColumns();
315            }
316    
317            @Override
318            public int getCurrentrow(int pid) {
319                    return query.getCurrentrow(pid);
320            }
321    
322            @Override
323            public String getData(int row, int col) throws IndexOutOfBoundsException {
324                    return query.getData(row, col);
325            }
326            
327            /*public synchronized Struct _getMetaData() {
328                    return query._getMetaData();
329            }*/
330    
331            @Override
332            public synchronized Array getMetaDataSimple() {
333                    return query.getMetaDataSimple();
334            }
335    
336            @Override
337            public String getName() {
338                    return query.getName();
339            }
340    
341            @Override
342            public Object getObject(String columnName) throws SQLException {
343                    return query.getObject(columnName);
344            }
345    
346            @Override
347            public Object getObject(int columnIndex) throws SQLException {
348                    return query.getObject(columnIndex);
349            }
350    
351            @Override
352            public int getRecordcount() {
353                    return query.getRecordcount();
354            }
355    
356            @Override
357            public int getRowCount() {
358                    return query.getRowCount();
359            }
360    
361            @Override
362            public SQL getSql() {
363                    return query.getSql();
364            }
365    
366            @Override
367            public String getString(int columnIndex) throws SQLException {
368                    return query.getString(columnIndex);
369            }
370    
371            @Override
372            public String getString(String columnName) throws SQLException {
373                    return query.getString(columnName);
374            }
375    
376            @Override
377            public synchronized int[] getTypes() {
378                    return query.getTypes();
379            }
380    
381            @Override
382            public synchronized Map getTypesAsMap() {
383                    return query.getTypesAsMap();
384            }
385    
386            @Override
387            public boolean go(int index) {
388                    return query.go(index);
389            }
390    
391            @Override
392            public boolean go(int index, int pid) {
393                    return query.go(index, pid);
394            }
395    
396            @Override
397            public boolean isCached() {
398                    return query.isCached();
399            }
400    
401            @Override
402            public boolean isEmpty() {
403                    return query.isEmpty();
404            }
405    
406            @Override
407            public boolean isInitalized() {
408                    return query.isInitalized();
409            }
410    
411    
412            @Override
413            public Iterator<Collection.Key> keyIterator() {
414                    return query.keyIterator();
415            }
416        
417        @Override
418            public Iterator<String> keysAsStringIterator() {
419            return query.keysAsStringIterator();
420        }
421    
422            @Override
423            public Iterator<Entry<Key, Object>> entryIterator() {
424                    return query.entryIterator();
425            }
426    
427            @Override
428            public Collection.Key[] keys() {
429                    return query.keys();
430            }
431    
432            @Override
433            public boolean next() {
434                    return query.next();
435            }
436    
437            @Override
438            public boolean next(int pid) {
439                    return query.next(pid);
440            }
441    
442            @Override
443            public Object remove(Collection.Key key) throws PageException {
444                    disconnectCache();
445                    return query.remove(key);
446            }
447    
448            @Override
449            public QueryColumn removeColumn(String key) throws DatabaseException {
450                    disconnectCache();
451                    return query.removeColumn(key);
452            }
453    
454            @Override
455            public QueryColumn removeColumn(Collection.Key key) throws DatabaseException {
456                    disconnectCache();
457                    return query.removeColumn(key);
458            }
459    
460            @Override
461            public synchronized QueryColumn removeColumnEL(String key) {
462                    disconnectCache();
463                    return query.removeColumnEL(key);
464            }
465    
466            @Override
467            public QueryColumn removeColumnEL(Collection.Key key) {
468                    disconnectCache();
469                    return query.removeColumnEL(key);
470            }
471    
472            @Override
473            public Object removeEL(Collection.Key key) {
474                    disconnectCache();
475                    return query.removeEL(key);
476            }
477    
478            @Override
479            public synchronized int removeRow(int row) throws PageException {
480                    disconnectCache();
481                    return query.removeRow(row);
482            }
483    
484            @Override
485            public int removeRowEL(int row) {
486                    disconnectCache();
487                    return query.removeRowEL(row);
488            }
489    
490            @Override
491            public void reset() {
492                    query.reset();
493            }
494    
495            @Override
496            public void reset(int pid) {
497                    query.reset(pid);
498            }
499    
500            @Override
501            public Object set(String key, Object value) throws PageException {
502                    disconnectCache();
503                    return query.set(key, value);
504            }
505    
506            @Override
507            public Object set(Collection.Key key, Object value) throws PageException {
508                    disconnectCache();
509                    return query.set(key, value);
510            }
511    
512            @Override
513            public Object set(PageContext pc, Collection.Key propertyName, Object value) throws PageException {
514                    disconnectCache();
515                    return query.set(pc, propertyName, value);
516            }
517    
518            @Override
519            public Object setAt(String key, int row, Object value) throws PageException {
520                    disconnectCache();
521                    return query.setAt(key, row, value);
522            }
523    
524            @Override
525            public Object setAt(Collection.Key key, int row, Object value) throws PageException {
526                    disconnectCache();
527                    return query.setAt(key, row, value);
528            }
529    
530            @Override
531            public Object setAtEL(String key, int row, Object value) {
532                    disconnectCache();
533                    return query.setAtEL(key, row, value);
534            }
535    
536            @Override
537            public Object setAtEL(Collection.Key key, int row, Object value) {
538                    disconnectCache();
539                    return query.setAtEL(key, row, value);
540            }
541    
542            @Override
543            public void setCached(boolean isCached) {
544                    query.setCached(isCached);
545            }
546    
547            @Override
548            public void setData(int row, int col, String value) throws IndexOutOfBoundsException {
549                    disconnectCache();
550                    query.setData(row, col, value);
551            }
552    
553            @Override
554            public Object setEL(String key, Object value) {
555                    disconnectCache();
556                    return query.setEL(key, value);
557            }
558    
559            @Override
560            public Object setEL(Collection.Key key, Object value) {
561                    disconnectCache();
562                    return query.setEL(key, value);
563            }
564    
565            @Override
566            public Object setEL(PageContext pc, Collection.Key propertyName, Object value) {
567                    disconnectCache();
568                    return query.setEL(pc, propertyName, value);
569            }
570    
571            @Override
572            public void setExecutionTime(long exeTime) {
573                    disconnectCache();
574                    query.setExecutionTime(exeTime);
575            }
576    
577    
578            @Override
579            public void setSql(SQL sql) {
580                    disconnectCache();
581                    query.setSql(sql);
582            }
583    
584            @Override
585            public int size() {
586                    return query.size();
587            }
588    
589            @Override
590            public void sort(String column) throws PageException {
591                    disconnectCache();
592                    query.sort(column);
593            }
594    
595            @Override
596            public void sort(Collection.Key column) throws PageException {
597                    disconnectCache();
598                    query.sort(column);
599            }
600    
601            @Override
602            public synchronized void sort(String strColumn, int order) throws PageException {
603                    disconnectCache();
604                    query.sort(strColumn, order);
605            }
606    
607            @Override
608            public synchronized void sort(Collection.Key keyColumn, int order) throws PageException {
609                    disconnectCache();
610                    query.sort(keyColumn, order);
611            }
612    
613            @Override
614            public DumpData toDumpData(PageContext pageContext, int maxlevel, DumpProperties dp) {
615                    return query.toDumpData(pageContext, maxlevel,dp);
616            }
617    
618            @Override
619            public String toString() {
620                    return query.toString();
621            }
622    
623            public QueryImpl getQuery() {
624                    return query;
625            }
626    
627            @Override
628            public void cancelRowUpdates() throws SQLException {
629                    disconnectCache();
630                    query.cancelRowUpdates();
631            }
632    
633            @Override
634            public void deleteRow() throws SQLException {
635                    disconnectCache();
636                    query.deleteRow();
637            }
638    
639            @Override
640            public void insertRow() throws SQLException {
641                    disconnectCache();
642                    query.insertRow();
643            }
644    
645            @Override
646            public synchronized void rename(Collection.Key columnName, Collection.Key newColumnName)
647                            throws ExpressionException {
648                    disconnectCache();
649                    query.rename(columnName, newColumnName);
650            }
651    
652            @Override
653            public boolean rowDeleted() throws SQLException {
654                    return query.rowDeleted();
655            }
656    
657            @Override
658            public boolean rowInserted() throws SQLException {
659                    return query.rowInserted();
660            }
661    
662            @Override
663            public boolean rowUpdated() throws SQLException {
664                    return query.rowUpdated();
665            }
666    
667            @Override
668            public void setFetchDirection(int direction) throws SQLException {
669                    disconnectCache();
670                    query.setFetchDirection(direction);
671            }
672    
673            @Override
674            public void setFetchSize(int rows) throws SQLException {
675                    disconnectCache();
676                    query.setFetchSize(rows);
677            }
678    
679            @Override
680            public void updateArray(int columnIndex, java.sql.Array x)
681                            throws SQLException {
682                    disconnectCache();
683                    query.updateArray(columnIndex, x);
684            }
685    
686            @Override
687            public void updateArray(String columnName, java.sql.Array x)
688                            throws SQLException {
689                    disconnectCache();
690                    query.updateArray(columnName, x);
691            }
692    
693            @Override
694            public void updateAsciiStream(int columnIndex, InputStream x, int length)
695                            throws SQLException {
696                    disconnectCache();
697                    query.updateAsciiStream(columnIndex, x, length);
698            }
699    
700            @Override
701            public void updateAsciiStream(String columnName, InputStream x, int length)
702                            throws SQLException {
703                    disconnectCache();
704                    query.updateAsciiStream(columnName, x, length);
705            }
706    
707            @Override
708            public void updateBigDecimal(int columnIndex, BigDecimal x)
709                            throws SQLException {
710                    disconnectCache();
711                    query.updateBigDecimal(columnIndex, x);
712            }
713    
714            @Override
715            public void updateBigDecimal(String columnName, BigDecimal x)
716                            throws SQLException {
717                    disconnectCache();
718                    query.updateBigDecimal(columnName, x);
719            }
720    
721            @Override
722            public void updateBinaryStream(int columnIndex, InputStream x, int length)
723                            throws SQLException {
724                    disconnectCache();
725                    query.updateBinaryStream(columnIndex, x, length);
726            }
727    
728            @Override
729            public void updateBinaryStream(String columnName, InputStream x, int length)
730                            throws SQLException {
731                    disconnectCache();
732                    query.updateBinaryStream(columnName, x, length);
733            }
734    
735            @Override
736            public void updateBlob(int columnIndex, Blob x) throws SQLException {
737                    disconnectCache();
738                    query.updateBlob(columnIndex, x);
739            }
740    
741            @Override
742            public void updateBlob(String columnName, Blob x) throws SQLException {
743                    disconnectCache();
744                    query.updateBlob(columnName, x);
745            }
746    
747            @Override
748            public void updateBoolean(int columnIndex, boolean x) throws SQLException {
749                    disconnectCache();
750                    query.updateBoolean(columnIndex, x);
751            }
752    
753            @Override
754            public void updateBoolean(String columnName, boolean x) throws SQLException {
755                    disconnectCache();
756                    query.updateBoolean(columnName, x);
757            }
758    
759            @Override
760            public void updateByte(int columnIndex, byte x) throws SQLException {
761                    disconnectCache();
762                    query.updateByte(columnIndex, x);
763            }
764    
765            @Override
766            public void updateByte(String columnName, byte x) throws SQLException {
767                    disconnectCache();
768                    query.updateByte(columnName, x);
769            }
770    
771            @Override
772            public void updateBytes(int columnIndex, byte[] x) throws SQLException {
773                    disconnectCache();
774                    query.updateBytes(columnIndex, x);
775            }
776    
777            @Override
778            public void updateBytes(String columnName, byte[] x) throws SQLException {
779                    disconnectCache();
780                    query.updateBytes(columnName, x);
781            }
782    
783            @Override
784            public void updateCharacterStream(int columnIndex, Reader reader, int length)
785                            throws SQLException {
786                    disconnectCache();
787                    query.updateCharacterStream(columnIndex, reader, length);
788            }
789    
790            @Override
791            public void updateCharacterStream(String columnName, Reader reader,
792                            int length) throws SQLException {
793                    disconnectCache();
794                    query.updateCharacterStream(columnName, reader, length);
795            }
796    
797            @Override
798            public void updateClob(int columnIndex, Clob x) throws SQLException {
799                    disconnectCache();
800                    query.updateClob(columnIndex, x);
801            }
802    
803            @Override
804            public void updateClob(String columnName, Clob x) throws SQLException {
805                    disconnectCache();
806                    query.updateClob(columnName, x);
807            }
808    
809            @Override
810            public void updateDate(int columnIndex, Date x) throws SQLException {
811                    disconnectCache();
812                    query.updateDate(columnIndex, x);
813            }
814    
815            @Override
816            public void updateDate(String columnName, Date x) throws SQLException {
817                    disconnectCache();
818                    query.updateDate(columnName, x);
819            }
820    
821            @Override
822            public void updateDouble(int columnIndex, double x) throws SQLException {
823                    disconnectCache();
824                    query.updateDouble(columnIndex, x);
825            }
826    
827            @Override
828            public void updateDouble(String columnName, double x) throws SQLException {
829                    disconnectCache();
830                    query.updateDouble(columnName, x);
831            }
832    
833            @Override
834            public void updateFloat(int columnIndex, float x) throws SQLException {
835                    disconnectCache();
836                    query.updateFloat(columnIndex, x);
837            }
838    
839            @Override
840            public void updateFloat(String columnName, float x) throws SQLException {
841                    disconnectCache();
842                    query.updateFloat(columnName, x);
843            }
844    
845            @Override
846            public void updateInt(int columnIndex, int x) throws SQLException {
847                    disconnectCache();
848                    query.updateInt(columnIndex, x);
849            }
850    
851            @Override
852            public void updateInt(String columnName, int x) throws SQLException {
853                    disconnectCache();
854                    query.updateInt(columnName, x);
855            }
856    
857            @Override
858            public void updateLong(int columnIndex, long x) throws SQLException {
859                    disconnectCache();
860                    query.updateLong(columnIndex, x);
861            }
862    
863            @Override
864            public void updateLong(String columnName, long x) throws SQLException {
865                    disconnectCache();
866                    query.updateLong(columnName, x);
867            }
868    
869            @Override
870            public void updateNull(int columnIndex) throws SQLException {
871                    disconnectCache();
872                    query.updateNull(columnIndex);
873            }
874    
875            @Override
876            public void updateNull(String columnName) throws SQLException {
877                    disconnectCache();
878                    query.updateNull(columnName);
879            }
880    
881            @Override
882            public void updateObject(int columnIndex, Object x) throws SQLException {
883                    disconnectCache();
884                    query.updateObject(columnIndex, x);
885            }
886    
887            @Override
888            public void updateObject(String columnName, Object x) throws SQLException {
889                    disconnectCache();
890                    query.updateObject(columnName, x);
891            }
892    
893            @Override
894            public void updateObject(int columnIndex, Object x, int scale)
895                            throws SQLException {
896                    disconnectCache();
897                    query.updateObject(columnIndex, x, scale);
898            }
899    
900            @Override
901            public void updateObject(String columnName, Object x, int scale)
902                            throws SQLException {
903                    disconnectCache();
904                    query.updateObject(columnName, x, scale);
905            }
906    
907            @Override
908            public void updateRef(int columnIndex, Ref x) throws SQLException {
909                    disconnectCache();
910                    query.updateRef(columnIndex, x);
911            }
912    
913            @Override
914            public void updateRef(String columnName, Ref x) throws SQLException {
915                    disconnectCache();
916                    query.updateRef(columnName, x);
917            }
918    
919            @Override
920            public void updateRow() throws SQLException {
921                    disconnectCache();
922                    query.updateRow();
923            }
924    
925            @Override
926            public void updateShort(int columnIndex, short x) throws SQLException {
927                    disconnectCache();
928                    query.updateShort(columnIndex, x);
929            }
930    
931            @Override
932            public void updateShort(String columnName, short x) throws SQLException {
933                    disconnectCache();
934                    query.updateShort(columnName, x);
935            }
936    
937            @Override
938            public void updateString(int columnIndex, String x) throws SQLException {
939                    disconnectCache();
940                    query.updateString(columnIndex, x);
941            }
942    
943            @Override
944            public void updateString(String columnName, String x) throws SQLException {
945                    disconnectCache();
946                    query.updateString(columnName, x);
947            }
948    
949            @Override
950            public void updateTime(int columnIndex, Time x) throws SQLException {
951                    disconnectCache();
952                    query.updateTime(columnIndex, x);
953            }
954    
955            @Override
956            public void updateTime(String columnName, Time x) throws SQLException {
957                    disconnectCache();
958                    query.updateTime(columnName, x);
959            }
960    
961            @Override
962            public void updateTimestamp(int columnIndex, Timestamp x)
963                            throws SQLException {
964                    disconnectCache();
965                    query.updateTimestamp(columnIndex, x);
966            }
967    
968            @Override
969            public void updateTimestamp(String columnName, Timestamp x)
970                            throws SQLException {
971                    disconnectCache();
972                    query.updateTimestamp(columnName, x);
973            }
974    
975            @Override
976            public boolean wasNull() {
977                    return query.wasNull();
978            }
979            
980    
981            @Override
982            public boolean absolute(int row) throws SQLException {
983                    return query.absolute(row);
984            }
985    
986            @Override
987            public void afterLast() throws SQLException {
988                    query.afterLast();
989            }
990    
991            @Override
992            public void beforeFirst() throws SQLException {
993                    query.beforeFirst();
994            }
995    
996            @Override
997            public void clearWarnings() throws SQLException {
998                    disconnectCache();
999                    query.clearWarnings();
1000            }
1001    
1002            @Override
1003            public void close() throws SQLException {
1004                    disconnectCache();
1005                    query.close();
1006            }
1007    
1008            @Override
1009            public int findColumn(String columnName) throws SQLException {
1010                    return query.findColumn(columnName);
1011            }
1012    
1013            @Override
1014            public boolean first() throws SQLException {
1015                    return query.first();
1016            }
1017    
1018            @Override
1019            public java.sql.Array getArray(int i) throws SQLException {
1020                    return query.getArray(i);
1021            }
1022    
1023            @Override
1024            public java.sql.Array getArray(String colName) throws SQLException {
1025                    return query.getArray(colName);
1026            }
1027    
1028            @Override
1029            public InputStream getAsciiStream(int columnIndex) throws SQLException {
1030                    return query.getAsciiStream(columnIndex);
1031            }
1032    
1033            @Override
1034            public InputStream getAsciiStream(String columnName) throws SQLException {
1035                    return query.getAsciiStream(columnName);
1036            }
1037    
1038            @Override
1039            public BigDecimal getBigDecimal(int columnIndex, int scale)
1040                            throws SQLException {
1041                    return query.getBigDecimal(columnIndex, scale);
1042            }
1043    
1044            @Override
1045            public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
1046                    return query.getBigDecimal(columnIndex);
1047            }
1048    
1049            @Override
1050            public BigDecimal getBigDecimal(String columnName, int scale)
1051                            throws SQLException {
1052                    return query.getBigDecimal(columnName, scale);
1053            }
1054    
1055            @Override
1056            public BigDecimal getBigDecimal(String columnName) throws SQLException {
1057                    return query.getBigDecimal(columnName);
1058            }
1059    
1060            @Override
1061            public InputStream getBinaryStream(int columnIndex) throws SQLException {
1062                    return query.getBinaryStream(columnIndex);
1063            }
1064    
1065            @Override
1066            public InputStream getBinaryStream(String columnName) throws SQLException {
1067                    return query.getBinaryStream(columnName);
1068            }
1069    
1070            @Override
1071            public Blob getBlob(int i) throws SQLException {
1072                    return query.getBlob(i);
1073            }
1074    
1075            @Override
1076            public Blob getBlob(String colName) throws SQLException {
1077                    return query.getBlob(colName);
1078            }
1079    
1080            @Override
1081            public byte getByte(int columnIndex) throws SQLException {
1082                    // TODO Auto-generated method stub
1083                    return query.getByte(columnIndex);
1084            }
1085    
1086            @Override
1087            public byte getByte(String columnName) throws SQLException {
1088                    // TODO Auto-generated method stub
1089                    return query.getByte(columnName);
1090            }
1091    
1092            @Override
1093            public byte[] getBytes(int columnIndex) throws SQLException {
1094                    // TODO Auto-generated method stub
1095                    return query.getBytes(columnIndex);
1096            }
1097    
1098            @Override
1099            public byte[] getBytes(String columnName) throws SQLException {
1100                    // TODO Auto-generated method stub
1101                    return query.getBytes(columnName);
1102            }
1103    
1104            @Override
1105            public Reader getCharacterStream(int columnIndex) throws SQLException {
1106                    // TODO Auto-generated method stub
1107                    return query.getCharacterStream(columnIndex);
1108            }
1109    
1110            @Override
1111            public Reader getCharacterStream(String columnName) throws SQLException {
1112                    // TODO Auto-generated method stub
1113                    return query.getCharacterStream(columnName);
1114            }
1115    
1116            @Override
1117            public Clob getClob(int i) throws SQLException {
1118                    // TODO Auto-generated method stub
1119                    return query.getClob(i);
1120            }
1121    
1122            @Override
1123            public Clob getClob(String colName) throws SQLException {
1124                    // TODO Auto-generated method stub
1125                    return query.getClob(colName);
1126            }
1127    
1128            @Override
1129            public String getColumnlist(boolean upperCase) {
1130                    // TODO Auto-generated method stub
1131                    return query.getColumnlist(upperCase);
1132            }
1133    
1134            @Override
1135            public Collection.Key getColumnName(int columnIndex) {
1136                    // TODO Auto-generated method stub
1137                    return query.getColumnName(columnIndex);
1138            }
1139    
1140            @Override
1141            public Collection.Key[] getColumnNames() {
1142                    // TODO Auto-generated method stub
1143                    return query.getColumnNames();
1144            }
1145    
1146            @Override
1147            public String[] getColumnNamesAsString() {
1148                    // TODO Auto-generated method stub
1149                    return query.getColumnNamesAsString();
1150            }
1151    
1152            @Override
1153            public int getConcurrency() throws SQLException {
1154                    // TODO Auto-generated method stub
1155                    return query.getConcurrency();
1156            }
1157    
1158            @Override
1159            public String getCursorName() throws SQLException {
1160                    // TODO Auto-generated method stub
1161                    return query.getCursorName();
1162            }
1163    
1164            @Override
1165            public Date getDate(int columnIndex, Calendar cal) throws SQLException {
1166                    // TODO Auto-generated method stub
1167                    return query.getDate(columnIndex, cal);
1168            }
1169    
1170            @Override
1171            public Date getDate(int columnIndex) throws SQLException {
1172                    // TODO Auto-generated method stub
1173                    return query.getDate(columnIndex);
1174            }
1175    
1176            @Override
1177            public Date getDate(String columnName, Calendar cal) throws SQLException {
1178                    // TODO Auto-generated method stub
1179                    return query.getDate(columnName, cal);
1180            }
1181    
1182            @Override
1183            public Date getDate(String columnName) throws SQLException {
1184                    // TODO Auto-generated method stub
1185                    return query.getDate(columnName);
1186            }
1187    
1188            @Override
1189            public double getDouble(int columnIndex) throws SQLException {
1190                    // TODO Auto-generated method stub
1191                    return query.getDouble(columnIndex);
1192            }
1193    
1194            @Override
1195            public double getDouble(String columnName) throws SQLException {
1196                    // TODO Auto-generated method stub
1197                    return query.getDouble(columnName);
1198            }
1199    
1200            @Override
1201            public int getFetchDirection() throws SQLException {
1202                    // TODO Auto-generated method stub
1203                    return query.getFetchDirection();
1204            }
1205    
1206            @Override
1207            public int getFetchSize() throws SQLException {
1208                    // TODO Auto-generated method stub
1209                    return query.getFetchSize();
1210            }
1211    
1212            @Override
1213            public float getFloat(int columnIndex) throws SQLException {
1214                    // TODO Auto-generated method stub
1215                    return query.getFloat(columnIndex);
1216            }
1217    
1218            @Override
1219            public float getFloat(String columnName) throws SQLException {
1220                    // TODO Auto-generated method stub
1221                    return query.getFloat(columnName);
1222            }
1223    
1224            @Override
1225            public Query getGeneratedKeys() {
1226                    // TODO Auto-generated method stub
1227                    return query.getGeneratedKeys();
1228            }
1229    
1230            @Override
1231            public int getInt(int columnIndex) throws SQLException {
1232                    // TODO Auto-generated method stub
1233                    return query.getInt(columnIndex);
1234            }
1235    
1236            @Override
1237            public int getInt(String columnName) throws SQLException {
1238                    // TODO Auto-generated method stub
1239                    return query.getInt(columnName);
1240            }
1241    
1242            @Override
1243            public long getLong(int columnIndex) throws SQLException {
1244                    // TODO Auto-generated method stub
1245                    return query.getLong(columnIndex);
1246            }
1247    
1248            @Override
1249            public long getLong(String columnName) throws SQLException {
1250                    // TODO Auto-generated method stub
1251                    return query.getLong(columnName);
1252            }
1253    
1254            @Override
1255            public ResultSetMetaData getMetaData() throws SQLException {
1256                    // TODO Auto-generated method stub
1257                    return query.getMetaData();
1258            }
1259    
1260            @Override
1261            public Object getObject(int i, Map map) throws SQLException {
1262                    // TODO Auto-generated method stub
1263                    return query.getObject(i, map);
1264            }
1265    
1266            @Override
1267            public Object getObject(String colName, Map map) throws SQLException {
1268                    // TODO Auto-generated method stub
1269                    return query.getObject(colName, map);
1270            }
1271    
1272            @Override
1273            public Ref getRef(int i) throws SQLException {
1274                    // TODO Auto-generated method stub
1275                    return query.getRef(i);
1276            }
1277    
1278            @Override
1279            public Ref getRef(String colName) throws SQLException {
1280                    // TODO Auto-generated method stub
1281                    return query.getRef(colName);
1282            }
1283    
1284            @Override
1285            public int getRow() throws SQLException {
1286                    // TODO Auto-generated method stub
1287                    return query.getRow();
1288            }
1289    
1290            @Override
1291            public short getShort(int columnIndex) throws SQLException {
1292                    // TODO Auto-generated method stub
1293                    return query.getShort(columnIndex);
1294            }
1295    
1296            @Override
1297            public short getShort(String columnName) throws SQLException {
1298                    // TODO Auto-generated method stub
1299                    return query.getShort(columnName);
1300            }
1301    
1302            @Override
1303            public Statement getStatement() throws SQLException {
1304                    // TODO Auto-generated method stub
1305                    return query.getStatement();
1306            }
1307    
1308            @Override
1309            public Time getTime(int columnIndex, Calendar cal) throws SQLException {
1310                    // TODO Auto-generated method stub
1311                    return query.getTime(columnIndex, cal);
1312            }
1313    
1314            @Override
1315            public Time getTime(int columnIndex) throws SQLException {
1316                    // TODO Auto-generated method stub
1317                    return query.getTime(columnIndex);
1318            }
1319    
1320            @Override
1321            public Time getTime(String columnName, Calendar cal) throws SQLException {
1322                    // TODO Auto-generated method stub
1323                    return query.getTime(columnName, cal);
1324            }
1325    
1326            @Override
1327            public Time getTime(String columnName) throws SQLException {
1328                    // TODO Auto-generated method stub
1329                    return query.getTime(columnName);
1330            }
1331    
1332            @Override
1333            public Timestamp getTimestamp(int columnIndex, Calendar cal)
1334                            throws SQLException {
1335                    // TODO Auto-generated method stub
1336                    return query.getTimestamp(columnIndex, cal);
1337            }
1338    
1339            @Override
1340            public Timestamp getTimestamp(int columnIndex) throws SQLException {
1341                    // TODO Auto-generated method stub
1342                    return query.getTimestamp(columnIndex);
1343            }
1344    
1345            @Override
1346            public Timestamp getTimestamp(String columnName, Calendar cal)
1347                            throws SQLException {
1348                    // TODO Auto-generated method stub
1349                    return query.getTimestamp(columnName, cal);
1350            }
1351    
1352            @Override
1353            public Timestamp getTimestamp(String columnName) throws SQLException {
1354                    // TODO Auto-generated method stub
1355                    return query.getTimestamp(columnName);
1356            }
1357    
1358            @Override
1359            public int getType() throws SQLException {
1360                    // TODO Auto-generated method stub
1361                    return query.getType();
1362            }
1363    
1364            @Override
1365            public InputStream getUnicodeStream(int columnIndex) throws SQLException {
1366                    // TODO Auto-generated method stub
1367                    return query.getUnicodeStream(columnIndex);
1368            }
1369    
1370            @Override
1371            public InputStream getUnicodeStream(String columnName) throws SQLException {
1372                    // TODO Auto-generated method stub
1373                    return query.getUnicodeStream(columnName);
1374            }
1375    
1376            @Override
1377            public int getUpdateCount() {
1378                    // TODO Auto-generated method stub
1379                    return query.getUpdateCount();
1380            }
1381    
1382            @Override
1383            public URL getURL(int columnIndex) throws SQLException {
1384                    // TODO Auto-generated method stub
1385                    return query.getURL(columnIndex);
1386            }
1387    
1388            @Override
1389            public URL getURL(String columnName) throws SQLException {
1390                    // TODO Auto-generated method stub
1391                    return query.getURL(columnName);
1392            }
1393    
1394            @Override
1395            public SQLWarning getWarnings() throws SQLException {
1396                    // TODO Auto-generated method stub
1397                    return query.getWarnings();
1398            }
1399    
1400            @Override
1401            public boolean isAfterLast() throws SQLException {
1402                    // TODO Auto-generated method stub
1403                    return query.isAfterLast();
1404            }
1405    
1406            @Override
1407            public boolean isBeforeFirst() throws SQLException {
1408                    // TODO Auto-generated method stub
1409                    return query.isBeforeFirst();
1410            }
1411    
1412            @Override
1413            public boolean isFirst() throws SQLException {
1414                    // TODO Auto-generated method stub
1415                    return query.isFirst();
1416            }
1417    
1418            @Override
1419            public boolean isLast() throws SQLException {
1420                    // TODO Auto-generated method stub
1421                    return query.isLast();
1422            }
1423    
1424            @Override
1425            public boolean last() throws SQLException {
1426                    // TODO Auto-generated method stub
1427                    return query.last();
1428            }
1429    
1430            @Override
1431            public void moveToCurrentRow() throws SQLException {
1432                    // TODO Auto-generated method stub
1433                    query.moveToCurrentRow();
1434            }
1435    
1436            @Override
1437            public void moveToInsertRow() throws SQLException {
1438                    // TODO Auto-generated method stub
1439                    query.moveToInsertRow();
1440            }
1441    
1442            @Override
1443            public boolean previous() {
1444                    // TODO Auto-generated method stub
1445                    return query.previous();
1446            }
1447    
1448            @Override
1449            public boolean previous(int pid) {
1450                    // TODO Auto-generated method stub
1451                    return query.previous(pid);
1452            }
1453    
1454            @Override
1455            public void refreshRow() throws SQLException {
1456                    // TODO Auto-generated method stub
1457                    query.refreshRow();
1458            }
1459    
1460            @Override
1461            public boolean relative(int rows) throws SQLException {
1462                    // TODO Auto-generated method stub
1463                    return query.relative(rows);
1464            }
1465    
1466            @Override
1467            public void setColumnNames(Collection.Key[] trg) throws PageException {
1468                    // TODO Auto-generated method stub
1469                    query.setColumnNames(trg);
1470            }
1471    
1472            @Override
1473            public Iterator<Object> valueIterator() {
1474                    // TODO Auto-generated method stub
1475                    return query.valueIterator();
1476            }
1477    
1478    }