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