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