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}