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