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