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 }