001 package railo.runtime.query; 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.Ref; 011 import java.sql.ResultSetMetaData; 012 import java.sql.SQLException; 013 import java.sql.SQLWarning; 014 import java.sql.Statement; 015 import java.sql.Time; 016 import java.sql.Timestamp; 017 import java.util.Calendar; 018 import java.util.HashMap; 019 import java.util.Iterator; 020 import java.util.Map; 021 import java.util.Map.Entry; 022 023 import railo.runtime.PageContext; 024 import railo.runtime.db.SQL; 025 import railo.runtime.dump.DumpData; 026 import railo.runtime.dump.DumpProperties; 027 import railo.runtime.exp.DatabaseException; 028 import railo.runtime.exp.ExpressionException; 029 import railo.runtime.exp.PageException; 030 import railo.runtime.type.Array; 031 import railo.runtime.type.Collection; 032 import railo.runtime.type.KeyImpl; 033 import railo.runtime.type.Query; 034 import railo.runtime.type.QueryColumn; 035 import railo.runtime.type.QueryImpl; 036 import railo.runtime.type.Struct; 037 import railo.runtime.type.dt.DateTime; 038 039 public class QueryCacheQuery extends QueryImpl { 040 041 private QueryImpl query; 042 private boolean isCloned=false; 043 private Map _columns=new HashMap(); 044 045 public QueryCacheQuery(QueryImpl query) throws DatabaseException { 046 super(query.keys(),0,query.getName()); 047 this.query=query; 048 } 049 050 protected void disconnectCache() { 051 if(isCloned) return; 052 this.query=query.cloneQuery(true); 053 isCloned=true; 054 } 055 056 @Override 057 public boolean addColumn(String columnName, Array content) throws DatabaseException { 058 disconnectCache(); 059 return query.addColumn(columnName, content); 060 } 061 062 @Override 063 public boolean addColumn(Collection.Key columnName, Array content) throws PageException { 064 disconnectCache(); 065 return query.addColumn(columnName, content); 066 } 067 068 @Override 069 public synchronized boolean addColumn(String columnName, Array content, int type) throws DatabaseException { 070 disconnectCache(); 071 return query.addColumn(columnName, content, type); 072 } 073 074 @Override 075 public boolean addColumn(Collection.Key columnName, Array content, int type) throws DatabaseException { 076 disconnectCache(); 077 return query.addColumn(columnName, content, type); 078 } 079 080 @Override 081 public synchronized boolean addRow(int count) { 082 disconnectCache(); 083 return query.addRow(count); 084 } 085 086 @Override 087 public int addRow() { 088 disconnectCache(); 089 return query.addRow(); 090 } 091 092 @Override 093 public Object call(PageContext pc, Collection.Key methodName, Object[] arguments) throws PageException { 094 return query.call(pc, methodName, arguments); 095 } 096 097 @Override 098 public Object callWithNamedValues(PageContext pc, Collection.Key methodName, Struct args) throws PageException { 099 return query.callWithNamedValues(pc, methodName, args); 100 } 101 102 @Override 103 public boolean castToBooleanValue() throws ExpressionException { 104 return query.castToBooleanValue(); 105 } 106 107 @Override 108 public Boolean castToBoolean(Boolean defaultValue) { 109 return query.castToBoolean(defaultValue); 110 } 111 112 @Override 113 public DateTime castToDateTime() throws ExpressionException { 114 return query.castToDateTime(); 115 } 116 117 @Override 118 public DateTime castToDateTime(DateTime defaultValue) { 119 return query.castToDateTime(defaultValue); 120 } 121 122 @Override 123 public double castToDoubleValue() throws ExpressionException { 124 return query.castToDoubleValue(); 125 } 126 127 @Override 128 public double castToDoubleValue(double defaultValue) { 129 return query.castToDoubleValue(defaultValue); 130 } 131 132 @Override 133 public String castToString() throws ExpressionException { 134 return query.castToString(); 135 } 136 137 @Override 138 public String castToString(String defaultValue) { 139 return query.castToString(defaultValue); 140 } 141 142 @Override 143 public void clear() { 144 disconnectCache(); 145 query.clear(); 146 } 147 148 @Override 149 public Object clone() { 150 return query.clone(); 151 } 152 153 @Override 154 public QueryImpl cloneQuery(boolean deepCopy) { 155 return query.cloneQuery(deepCopy); 156 } 157 158 @Override 159 public int compareTo(boolean b) throws ExpressionException { 160 return query.compareTo(b); 161 } 162 163 @Override 164 public int compareTo(DateTime dt) throws PageException { 165 return query.compareTo(dt); 166 } 167 168 @Override 169 public int compareTo(double d) throws PageException { 170 return query.compareTo(d); 171 } 172 173 @Override 174 public int compareTo(String str) throws PageException { 175 return query.compareTo(str); 176 } 177 178 @Override 179 public boolean containsKey(String key) { 180 return query.containsKey(key); 181 } 182 183 @Override 184 public boolean containsKey(Collection.Key key) { 185 return query.containsKey(key); 186 } 187 188 @Override 189 public synchronized boolean cutRowsTo(int maxrows) { 190 disconnectCache(); 191 return query.cutRowsTo(maxrows); 192 } 193 194 @Override 195 public Collection duplicate(boolean deepCopy) { 196 return query.duplicate(deepCopy); 197 } 198 199 @Override 200 public int executionTime() { 201 return query.executionTime(); 202 } 203 204 @Override 205 public Object get(String key, Object defaultValue) { 206 return query.get(key, defaultValue); 207 } 208 209 @Override 210 public Object get(Collection.Key key, Object defaultValue) { 211 return query.get(key, defaultValue); 212 } 213 214 @Override 215 public Object get(String key) throws PageException { 216 return query.get(key); 217 } 218 219 @Override 220 public Object get(Collection.Key key) throws PageException { 221 return query.get(key); 222 } 223 224 @Override 225 public Object get(PageContext pc, Collection.Key key, Object defaultValue) { 226 return query.get(pc, key, defaultValue); 227 } 228 229 @Override 230 public Object get(PageContext pc, Collection.Key key) throws PageException { 231 return query.get(pc, key); 232 } 233 234 @Override 235 public Object getAt(String key, int row, Object defaultValue) { 236 return query.getAt(key, row, defaultValue); 237 } 238 239 @Override 240 public Object getAt(Collection.Key key, int row, Object defaultValue) { 241 return query.getAt(key, row, defaultValue); 242 } 243 244 @Override 245 public Object getAt(String key, int row) throws PageException { 246 return query.getAt(key, row); 247 } 248 249 @Override 250 public Object getAt(Collection.Key key, int row) throws PageException { 251 return query.getAt(key, row); 252 } 253 254 @Override 255 public boolean getBoolean(int columnIndex) throws SQLException { 256 return query.getBoolean(columnIndex); 257 } 258 259 @Override 260 public boolean getBoolean(String columnName) throws SQLException { 261 return query.getBoolean(columnName); 262 } 263 264 @Override 265 public QueryColumn getColumn(String key) throws DatabaseException { 266 return getColumn(KeyImpl.getInstance(key)); 267 } 268 269 @Override 270 public QueryColumn getColumn(Collection.Key key) throws DatabaseException { 271 if(!isCloned) { 272 QueryColumn column = (QueryColumn) _columns.get(key); 273 if(column==null) { 274 column=QueryCacheQueryColumn.getColumn(this,key); 275 _columns.put(key, column); 276 } 277 return column; 278 } 279 //disconnectCache(); 280 return query.getColumn(key); 281 } 282 283 @Override 284 public QueryColumn getColumn(String key, QueryColumn defaultValue) { 285 return getColumn(KeyImpl.getInstance(key),defaultValue); 286 } 287 288 @Override 289 public QueryColumn getColumn(Collection.Key key, QueryColumn defaultValue) { 290 if(!isCloned) { 291 QueryColumn column = (QueryColumn) _columns.get(key); 292 if(column==null) { 293 column=QueryCacheQueryColumn.getColumn(this,key,defaultValue); 294 if(column!=defaultValue)_columns.put(key, column); 295 } 296 return column; 297 } 298 //disconnectCache(); 299 return query.getColumn(key, defaultValue); 300 } 301 302 @Override 303 public int getColumnIndex(String coulmnName) { 304 return query.getColumnIndex(coulmnName); 305 } 306 307 @Override 308 public String getColumnlist() { 309 return query.getColumnlist(); 310 } 311 312 @Override 313 public String[] getColumns() { 314 return query.getColumns(); 315 } 316 317 @Override 318 public int getCurrentrow(int pid) { 319 return query.getCurrentrow(pid); 320 } 321 322 @Override 323 public String getData(int row, int col) throws IndexOutOfBoundsException { 324 return query.getData(row, col); 325 } 326 327 /*public synchronized Struct _getMetaData() { 328 return query._getMetaData(); 329 }*/ 330 331 @Override 332 public synchronized Array getMetaDataSimple() { 333 return query.getMetaDataSimple(); 334 } 335 336 @Override 337 public String getName() { 338 return query.getName(); 339 } 340 341 @Override 342 public Object getObject(String columnName) throws SQLException { 343 return query.getObject(columnName); 344 } 345 346 @Override 347 public Object getObject(int columnIndex) throws SQLException { 348 return query.getObject(columnIndex); 349 } 350 351 @Override 352 public int getRecordcount() { 353 return query.getRecordcount(); 354 } 355 356 @Override 357 public int getRowCount() { 358 return query.getRowCount(); 359 } 360 361 @Override 362 public SQL getSql() { 363 return query.getSql(); 364 } 365 366 @Override 367 public String getString(int columnIndex) throws SQLException { 368 return query.getString(columnIndex); 369 } 370 371 @Override 372 public String getString(String columnName) throws SQLException { 373 return query.getString(columnName); 374 } 375 376 @Override 377 public synchronized int[] getTypes() { 378 return query.getTypes(); 379 } 380 381 @Override 382 public synchronized Map getTypesAsMap() { 383 return query.getTypesAsMap(); 384 } 385 386 @Override 387 public boolean go(int index) { 388 return query.go(index); 389 } 390 391 @Override 392 public boolean go(int index, int pid) { 393 return query.go(index, pid); 394 } 395 396 @Override 397 public boolean isCached() { 398 return query.isCached(); 399 } 400 401 @Override 402 public boolean isEmpty() { 403 return query.isEmpty(); 404 } 405 406 @Override 407 public boolean isInitalized() { 408 return query.isInitalized(); 409 } 410 411 412 @Override 413 public Iterator<Collection.Key> keyIterator() { 414 return query.keyIterator(); 415 } 416 417 @Override 418 public Iterator<String> keysAsStringIterator() { 419 return query.keysAsStringIterator(); 420 } 421 422 @Override 423 public Iterator<Entry<Key, Object>> entryIterator() { 424 return query.entryIterator(); 425 } 426 427 @Override 428 public Collection.Key[] keys() { 429 return query.keys(); 430 } 431 432 @Override 433 public boolean next() { 434 return query.next(); 435 } 436 437 @Override 438 public boolean next(int pid) { 439 return query.next(pid); 440 } 441 442 @Override 443 public Object remove(Collection.Key key) throws PageException { 444 disconnectCache(); 445 return query.remove(key); 446 } 447 448 @Override 449 public QueryColumn removeColumn(String key) throws DatabaseException { 450 disconnectCache(); 451 return query.removeColumn(key); 452 } 453 454 @Override 455 public QueryColumn removeColumn(Collection.Key key) throws DatabaseException { 456 disconnectCache(); 457 return query.removeColumn(key); 458 } 459 460 @Override 461 public synchronized QueryColumn removeColumnEL(String key) { 462 disconnectCache(); 463 return query.removeColumnEL(key); 464 } 465 466 @Override 467 public QueryColumn removeColumnEL(Collection.Key key) { 468 disconnectCache(); 469 return query.removeColumnEL(key); 470 } 471 472 @Override 473 public Object removeEL(Collection.Key key) { 474 disconnectCache(); 475 return query.removeEL(key); 476 } 477 478 @Override 479 public synchronized int removeRow(int row) throws PageException { 480 disconnectCache(); 481 return query.removeRow(row); 482 } 483 484 @Override 485 public int removeRowEL(int row) { 486 disconnectCache(); 487 return query.removeRowEL(row); 488 } 489 490 @Override 491 public void reset() { 492 query.reset(); 493 } 494 495 @Override 496 public void reset(int pid) { 497 query.reset(pid); 498 } 499 500 @Override 501 public Object set(String key, Object value) throws PageException { 502 disconnectCache(); 503 return query.set(key, value); 504 } 505 506 @Override 507 public Object set(Collection.Key key, Object value) throws PageException { 508 disconnectCache(); 509 return query.set(key, value); 510 } 511 512 @Override 513 public Object set(PageContext pc, Collection.Key propertyName, Object value) throws PageException { 514 disconnectCache(); 515 return query.set(pc, propertyName, value); 516 } 517 518 @Override 519 public Object setAt(String key, int row, Object value) throws PageException { 520 disconnectCache(); 521 return query.setAt(key, row, value); 522 } 523 524 @Override 525 public Object setAt(Collection.Key key, int row, Object value) throws PageException { 526 disconnectCache(); 527 return query.setAt(key, row, value); 528 } 529 530 @Override 531 public Object setAtEL(String key, int row, Object value) { 532 disconnectCache(); 533 return query.setAtEL(key, row, value); 534 } 535 536 @Override 537 public Object setAtEL(Collection.Key key, int row, Object value) { 538 disconnectCache(); 539 return query.setAtEL(key, row, value); 540 } 541 542 @Override 543 public void setCached(boolean isCached) { 544 query.setCached(isCached); 545 } 546 547 @Override 548 public void setData(int row, int col, String value) throws IndexOutOfBoundsException { 549 disconnectCache(); 550 query.setData(row, col, value); 551 } 552 553 @Override 554 public Object setEL(String key, Object value) { 555 disconnectCache(); 556 return query.setEL(key, value); 557 } 558 559 @Override 560 public Object setEL(Collection.Key key, Object value) { 561 disconnectCache(); 562 return query.setEL(key, value); 563 } 564 565 @Override 566 public Object setEL(PageContext pc, Collection.Key propertyName, Object value) { 567 disconnectCache(); 568 return query.setEL(pc, propertyName, value); 569 } 570 571 @Override 572 public void setExecutionTime(long exeTime) { 573 disconnectCache(); 574 query.setExecutionTime(exeTime); 575 } 576 577 578 @Override 579 public void setSql(SQL sql) { 580 disconnectCache(); 581 query.setSql(sql); 582 } 583 584 @Override 585 public int size() { 586 return query.size(); 587 } 588 589 @Override 590 public void sort(String column) throws PageException { 591 disconnectCache(); 592 query.sort(column); 593 } 594 595 @Override 596 public void sort(Collection.Key column) throws PageException { 597 disconnectCache(); 598 query.sort(column); 599 } 600 601 @Override 602 public synchronized void sort(String strColumn, int order) throws PageException { 603 disconnectCache(); 604 query.sort(strColumn, order); 605 } 606 607 @Override 608 public synchronized void sort(Collection.Key keyColumn, int order) throws PageException { 609 disconnectCache(); 610 query.sort(keyColumn, order); 611 } 612 613 @Override 614 public DumpData toDumpData(PageContext pageContext, int maxlevel, DumpProperties dp) { 615 return query.toDumpData(pageContext, maxlevel,dp); 616 } 617 618 @Override 619 public String toString() { 620 return query.toString(); 621 } 622 623 public QueryImpl getQuery() { 624 return query; 625 } 626 627 @Override 628 public void cancelRowUpdates() throws SQLException { 629 disconnectCache(); 630 query.cancelRowUpdates(); 631 } 632 633 @Override 634 public void deleteRow() throws SQLException { 635 disconnectCache(); 636 query.deleteRow(); 637 } 638 639 @Override 640 public void insertRow() throws SQLException { 641 disconnectCache(); 642 query.insertRow(); 643 } 644 645 @Override 646 public synchronized void rename(Collection.Key columnName, Collection.Key newColumnName) 647 throws ExpressionException { 648 disconnectCache(); 649 query.rename(columnName, newColumnName); 650 } 651 652 @Override 653 public boolean rowDeleted() throws SQLException { 654 return query.rowDeleted(); 655 } 656 657 @Override 658 public boolean rowInserted() throws SQLException { 659 return query.rowInserted(); 660 } 661 662 @Override 663 public boolean rowUpdated() throws SQLException { 664 return query.rowUpdated(); 665 } 666 667 @Override 668 public void setFetchDirection(int direction) throws SQLException { 669 disconnectCache(); 670 query.setFetchDirection(direction); 671 } 672 673 @Override 674 public void setFetchSize(int rows) throws SQLException { 675 disconnectCache(); 676 query.setFetchSize(rows); 677 } 678 679 @Override 680 public void updateArray(int columnIndex, java.sql.Array x) 681 throws SQLException { 682 disconnectCache(); 683 query.updateArray(columnIndex, x); 684 } 685 686 @Override 687 public void updateArray(String columnName, java.sql.Array x) 688 throws SQLException { 689 disconnectCache(); 690 query.updateArray(columnName, x); 691 } 692 693 @Override 694 public void updateAsciiStream(int columnIndex, InputStream x, int length) 695 throws SQLException { 696 disconnectCache(); 697 query.updateAsciiStream(columnIndex, x, length); 698 } 699 700 @Override 701 public void updateAsciiStream(String columnName, InputStream x, int length) 702 throws SQLException { 703 disconnectCache(); 704 query.updateAsciiStream(columnName, x, length); 705 } 706 707 @Override 708 public void updateBigDecimal(int columnIndex, BigDecimal x) 709 throws SQLException { 710 disconnectCache(); 711 query.updateBigDecimal(columnIndex, x); 712 } 713 714 @Override 715 public void updateBigDecimal(String columnName, BigDecimal x) 716 throws SQLException { 717 disconnectCache(); 718 query.updateBigDecimal(columnName, x); 719 } 720 721 @Override 722 public void updateBinaryStream(int columnIndex, InputStream x, int length) 723 throws SQLException { 724 disconnectCache(); 725 query.updateBinaryStream(columnIndex, x, length); 726 } 727 728 @Override 729 public void updateBinaryStream(String columnName, InputStream x, int length) 730 throws SQLException { 731 disconnectCache(); 732 query.updateBinaryStream(columnName, x, length); 733 } 734 735 @Override 736 public void updateBlob(int columnIndex, Blob x) throws SQLException { 737 disconnectCache(); 738 query.updateBlob(columnIndex, x); 739 } 740 741 @Override 742 public void updateBlob(String columnName, Blob x) throws SQLException { 743 disconnectCache(); 744 query.updateBlob(columnName, x); 745 } 746 747 @Override 748 public void updateBoolean(int columnIndex, boolean x) throws SQLException { 749 disconnectCache(); 750 query.updateBoolean(columnIndex, x); 751 } 752 753 @Override 754 public void updateBoolean(String columnName, boolean x) throws SQLException { 755 disconnectCache(); 756 query.updateBoolean(columnName, x); 757 } 758 759 @Override 760 public void updateByte(int columnIndex, byte x) throws SQLException { 761 disconnectCache(); 762 query.updateByte(columnIndex, x); 763 } 764 765 @Override 766 public void updateByte(String columnName, byte x) throws SQLException { 767 disconnectCache(); 768 query.updateByte(columnName, x); 769 } 770 771 @Override 772 public void updateBytes(int columnIndex, byte[] x) throws SQLException { 773 disconnectCache(); 774 query.updateBytes(columnIndex, x); 775 } 776 777 @Override 778 public void updateBytes(String columnName, byte[] x) throws SQLException { 779 disconnectCache(); 780 query.updateBytes(columnName, x); 781 } 782 783 @Override 784 public void updateCharacterStream(int columnIndex, Reader reader, int length) 785 throws SQLException { 786 disconnectCache(); 787 query.updateCharacterStream(columnIndex, reader, length); 788 } 789 790 @Override 791 public void updateCharacterStream(String columnName, Reader reader, 792 int length) throws SQLException { 793 disconnectCache(); 794 query.updateCharacterStream(columnName, reader, length); 795 } 796 797 @Override 798 public void updateClob(int columnIndex, Clob x) throws SQLException { 799 disconnectCache(); 800 query.updateClob(columnIndex, x); 801 } 802 803 @Override 804 public void updateClob(String columnName, Clob x) throws SQLException { 805 disconnectCache(); 806 query.updateClob(columnName, x); 807 } 808 809 @Override 810 public void updateDate(int columnIndex, Date x) throws SQLException { 811 disconnectCache(); 812 query.updateDate(columnIndex, x); 813 } 814 815 @Override 816 public void updateDate(String columnName, Date x) throws SQLException { 817 disconnectCache(); 818 query.updateDate(columnName, x); 819 } 820 821 @Override 822 public void updateDouble(int columnIndex, double x) throws SQLException { 823 disconnectCache(); 824 query.updateDouble(columnIndex, x); 825 } 826 827 @Override 828 public void updateDouble(String columnName, double x) throws SQLException { 829 disconnectCache(); 830 query.updateDouble(columnName, x); 831 } 832 833 @Override 834 public void updateFloat(int columnIndex, float x) throws SQLException { 835 disconnectCache(); 836 query.updateFloat(columnIndex, x); 837 } 838 839 @Override 840 public void updateFloat(String columnName, float x) throws SQLException { 841 disconnectCache(); 842 query.updateFloat(columnName, x); 843 } 844 845 @Override 846 public void updateInt(int columnIndex, int x) throws SQLException { 847 disconnectCache(); 848 query.updateInt(columnIndex, x); 849 } 850 851 @Override 852 public void updateInt(String columnName, int x) throws SQLException { 853 disconnectCache(); 854 query.updateInt(columnName, x); 855 } 856 857 @Override 858 public void updateLong(int columnIndex, long x) throws SQLException { 859 disconnectCache(); 860 query.updateLong(columnIndex, x); 861 } 862 863 @Override 864 public void updateLong(String columnName, long x) throws SQLException { 865 disconnectCache(); 866 query.updateLong(columnName, x); 867 } 868 869 @Override 870 public void updateNull(int columnIndex) throws SQLException { 871 disconnectCache(); 872 query.updateNull(columnIndex); 873 } 874 875 @Override 876 public void updateNull(String columnName) throws SQLException { 877 disconnectCache(); 878 query.updateNull(columnName); 879 } 880 881 @Override 882 public void updateObject(int columnIndex, Object x) throws SQLException { 883 disconnectCache(); 884 query.updateObject(columnIndex, x); 885 } 886 887 @Override 888 public void updateObject(String columnName, Object x) throws SQLException { 889 disconnectCache(); 890 query.updateObject(columnName, x); 891 } 892 893 @Override 894 public void updateObject(int columnIndex, Object x, int scale) 895 throws SQLException { 896 disconnectCache(); 897 query.updateObject(columnIndex, x, scale); 898 } 899 900 @Override 901 public void updateObject(String columnName, Object x, int scale) 902 throws SQLException { 903 disconnectCache(); 904 query.updateObject(columnName, x, scale); 905 } 906 907 @Override 908 public void updateRef(int columnIndex, Ref x) throws SQLException { 909 disconnectCache(); 910 query.updateRef(columnIndex, x); 911 } 912 913 @Override 914 public void updateRef(String columnName, Ref x) throws SQLException { 915 disconnectCache(); 916 query.updateRef(columnName, x); 917 } 918 919 @Override 920 public void updateRow() throws SQLException { 921 disconnectCache(); 922 query.updateRow(); 923 } 924 925 @Override 926 public void updateShort(int columnIndex, short x) throws SQLException { 927 disconnectCache(); 928 query.updateShort(columnIndex, x); 929 } 930 931 @Override 932 public void updateShort(String columnName, short x) throws SQLException { 933 disconnectCache(); 934 query.updateShort(columnName, x); 935 } 936 937 @Override 938 public void updateString(int columnIndex, String x) throws SQLException { 939 disconnectCache(); 940 query.updateString(columnIndex, x); 941 } 942 943 @Override 944 public void updateString(String columnName, String x) throws SQLException { 945 disconnectCache(); 946 query.updateString(columnName, x); 947 } 948 949 @Override 950 public void updateTime(int columnIndex, Time x) throws SQLException { 951 disconnectCache(); 952 query.updateTime(columnIndex, x); 953 } 954 955 @Override 956 public void updateTime(String columnName, Time x) throws SQLException { 957 disconnectCache(); 958 query.updateTime(columnName, x); 959 } 960 961 @Override 962 public void updateTimestamp(int columnIndex, Timestamp x) 963 throws SQLException { 964 disconnectCache(); 965 query.updateTimestamp(columnIndex, x); 966 } 967 968 @Override 969 public void updateTimestamp(String columnName, Timestamp x) 970 throws SQLException { 971 disconnectCache(); 972 query.updateTimestamp(columnName, x); 973 } 974 975 @Override 976 public boolean wasNull() { 977 return query.wasNull(); 978 } 979 980 981 @Override 982 public boolean absolute(int row) throws SQLException { 983 return query.absolute(row); 984 } 985 986 @Override 987 public void afterLast() throws SQLException { 988 query.afterLast(); 989 } 990 991 @Override 992 public void beforeFirst() throws SQLException { 993 query.beforeFirst(); 994 } 995 996 @Override 997 public void clearWarnings() throws SQLException { 998 disconnectCache(); 999 query.clearWarnings(); 1000 } 1001 1002 @Override 1003 public void close() throws SQLException { 1004 disconnectCache(); 1005 query.close(); 1006 } 1007 1008 @Override 1009 public int findColumn(String columnName) throws SQLException { 1010 return query.findColumn(columnName); 1011 } 1012 1013 @Override 1014 public boolean first() throws SQLException { 1015 return query.first(); 1016 } 1017 1018 @Override 1019 public java.sql.Array getArray(int i) throws SQLException { 1020 return query.getArray(i); 1021 } 1022 1023 @Override 1024 public java.sql.Array getArray(String colName) throws SQLException { 1025 return query.getArray(colName); 1026 } 1027 1028 @Override 1029 public InputStream getAsciiStream(int columnIndex) throws SQLException { 1030 return query.getAsciiStream(columnIndex); 1031 } 1032 1033 @Override 1034 public InputStream getAsciiStream(String columnName) throws SQLException { 1035 return query.getAsciiStream(columnName); 1036 } 1037 1038 @Override 1039 public BigDecimal getBigDecimal(int columnIndex, int scale) 1040 throws SQLException { 1041 return query.getBigDecimal(columnIndex, scale); 1042 } 1043 1044 @Override 1045 public BigDecimal getBigDecimal(int columnIndex) throws SQLException { 1046 return query.getBigDecimal(columnIndex); 1047 } 1048 1049 @Override 1050 public BigDecimal getBigDecimal(String columnName, int scale) 1051 throws SQLException { 1052 return query.getBigDecimal(columnName, scale); 1053 } 1054 1055 @Override 1056 public BigDecimal getBigDecimal(String columnName) throws SQLException { 1057 return query.getBigDecimal(columnName); 1058 } 1059 1060 @Override 1061 public InputStream getBinaryStream(int columnIndex) throws SQLException { 1062 return query.getBinaryStream(columnIndex); 1063 } 1064 1065 @Override 1066 public InputStream getBinaryStream(String columnName) throws SQLException { 1067 return query.getBinaryStream(columnName); 1068 } 1069 1070 @Override 1071 public Blob getBlob(int i) throws SQLException { 1072 return query.getBlob(i); 1073 } 1074 1075 @Override 1076 public Blob getBlob(String colName) throws SQLException { 1077 return query.getBlob(colName); 1078 } 1079 1080 @Override 1081 public byte getByte(int columnIndex) throws SQLException { 1082 // TODO Auto-generated method stub 1083 return query.getByte(columnIndex); 1084 } 1085 1086 @Override 1087 public byte getByte(String columnName) throws SQLException { 1088 // TODO Auto-generated method stub 1089 return query.getByte(columnName); 1090 } 1091 1092 @Override 1093 public byte[] getBytes(int columnIndex) throws SQLException { 1094 // TODO Auto-generated method stub 1095 return query.getBytes(columnIndex); 1096 } 1097 1098 @Override 1099 public byte[] getBytes(String columnName) throws SQLException { 1100 // TODO Auto-generated method stub 1101 return query.getBytes(columnName); 1102 } 1103 1104 @Override 1105 public Reader getCharacterStream(int columnIndex) throws SQLException { 1106 // TODO Auto-generated method stub 1107 return query.getCharacterStream(columnIndex); 1108 } 1109 1110 @Override 1111 public Reader getCharacterStream(String columnName) throws SQLException { 1112 // TODO Auto-generated method stub 1113 return query.getCharacterStream(columnName); 1114 } 1115 1116 @Override 1117 public Clob getClob(int i) throws SQLException { 1118 // TODO Auto-generated method stub 1119 return query.getClob(i); 1120 } 1121 1122 @Override 1123 public Clob getClob(String colName) throws SQLException { 1124 // TODO Auto-generated method stub 1125 return query.getClob(colName); 1126 } 1127 1128 @Override 1129 public String getColumnlist(boolean upperCase) { 1130 // TODO Auto-generated method stub 1131 return query.getColumnlist(upperCase); 1132 } 1133 1134 @Override 1135 public Collection.Key getColumnName(int columnIndex) { 1136 // TODO Auto-generated method stub 1137 return query.getColumnName(columnIndex); 1138 } 1139 1140 @Override 1141 public Collection.Key[] getColumnNames() { 1142 // TODO Auto-generated method stub 1143 return query.getColumnNames(); 1144 } 1145 1146 @Override 1147 public String[] getColumnNamesAsString() { 1148 // TODO Auto-generated method stub 1149 return query.getColumnNamesAsString(); 1150 } 1151 1152 @Override 1153 public int getConcurrency() throws SQLException { 1154 // TODO Auto-generated method stub 1155 return query.getConcurrency(); 1156 } 1157 1158 @Override 1159 public String getCursorName() throws SQLException { 1160 // TODO Auto-generated method stub 1161 return query.getCursorName(); 1162 } 1163 1164 @Override 1165 public Date getDate(int columnIndex, Calendar cal) throws SQLException { 1166 // TODO Auto-generated method stub 1167 return query.getDate(columnIndex, cal); 1168 } 1169 1170 @Override 1171 public Date getDate(int columnIndex) throws SQLException { 1172 // TODO Auto-generated method stub 1173 return query.getDate(columnIndex); 1174 } 1175 1176 @Override 1177 public Date getDate(String columnName, Calendar cal) throws SQLException { 1178 // TODO Auto-generated method stub 1179 return query.getDate(columnName, cal); 1180 } 1181 1182 @Override 1183 public Date getDate(String columnName) throws SQLException { 1184 // TODO Auto-generated method stub 1185 return query.getDate(columnName); 1186 } 1187 1188 @Override 1189 public double getDouble(int columnIndex) throws SQLException { 1190 // TODO Auto-generated method stub 1191 return query.getDouble(columnIndex); 1192 } 1193 1194 @Override 1195 public double getDouble(String columnName) throws SQLException { 1196 // TODO Auto-generated method stub 1197 return query.getDouble(columnName); 1198 } 1199 1200 @Override 1201 public int getFetchDirection() throws SQLException { 1202 // TODO Auto-generated method stub 1203 return query.getFetchDirection(); 1204 } 1205 1206 @Override 1207 public int getFetchSize() throws SQLException { 1208 // TODO Auto-generated method stub 1209 return query.getFetchSize(); 1210 } 1211 1212 @Override 1213 public float getFloat(int columnIndex) throws SQLException { 1214 // TODO Auto-generated method stub 1215 return query.getFloat(columnIndex); 1216 } 1217 1218 @Override 1219 public float getFloat(String columnName) throws SQLException { 1220 // TODO Auto-generated method stub 1221 return query.getFloat(columnName); 1222 } 1223 1224 @Override 1225 public Query getGeneratedKeys() { 1226 // TODO Auto-generated method stub 1227 return query.getGeneratedKeys(); 1228 } 1229 1230 @Override 1231 public int getInt(int columnIndex) throws SQLException { 1232 // TODO Auto-generated method stub 1233 return query.getInt(columnIndex); 1234 } 1235 1236 @Override 1237 public int getInt(String columnName) throws SQLException { 1238 // TODO Auto-generated method stub 1239 return query.getInt(columnName); 1240 } 1241 1242 @Override 1243 public long getLong(int columnIndex) throws SQLException { 1244 // TODO Auto-generated method stub 1245 return query.getLong(columnIndex); 1246 } 1247 1248 @Override 1249 public long getLong(String columnName) throws SQLException { 1250 // TODO Auto-generated method stub 1251 return query.getLong(columnName); 1252 } 1253 1254 @Override 1255 public ResultSetMetaData getMetaData() throws SQLException { 1256 // TODO Auto-generated method stub 1257 return query.getMetaData(); 1258 } 1259 1260 @Override 1261 public Object getObject(int i, Map map) throws SQLException { 1262 // TODO Auto-generated method stub 1263 return query.getObject(i, map); 1264 } 1265 1266 @Override 1267 public Object getObject(String colName, Map map) throws SQLException { 1268 // TODO Auto-generated method stub 1269 return query.getObject(colName, map); 1270 } 1271 1272 @Override 1273 public Ref getRef(int i) throws SQLException { 1274 // TODO Auto-generated method stub 1275 return query.getRef(i); 1276 } 1277 1278 @Override 1279 public Ref getRef(String colName) throws SQLException { 1280 // TODO Auto-generated method stub 1281 return query.getRef(colName); 1282 } 1283 1284 @Override 1285 public int getRow() throws SQLException { 1286 // TODO Auto-generated method stub 1287 return query.getRow(); 1288 } 1289 1290 @Override 1291 public short getShort(int columnIndex) throws SQLException { 1292 // TODO Auto-generated method stub 1293 return query.getShort(columnIndex); 1294 } 1295 1296 @Override 1297 public short getShort(String columnName) throws SQLException { 1298 // TODO Auto-generated method stub 1299 return query.getShort(columnName); 1300 } 1301 1302 @Override 1303 public Statement getStatement() throws SQLException { 1304 // TODO Auto-generated method stub 1305 return query.getStatement(); 1306 } 1307 1308 @Override 1309 public Time getTime(int columnIndex, Calendar cal) throws SQLException { 1310 // TODO Auto-generated method stub 1311 return query.getTime(columnIndex, cal); 1312 } 1313 1314 @Override 1315 public Time getTime(int columnIndex) throws SQLException { 1316 // TODO Auto-generated method stub 1317 return query.getTime(columnIndex); 1318 } 1319 1320 @Override 1321 public Time getTime(String columnName, Calendar cal) throws SQLException { 1322 // TODO Auto-generated method stub 1323 return query.getTime(columnName, cal); 1324 } 1325 1326 @Override 1327 public Time getTime(String columnName) throws SQLException { 1328 // TODO Auto-generated method stub 1329 return query.getTime(columnName); 1330 } 1331 1332 @Override 1333 public Timestamp getTimestamp(int columnIndex, Calendar cal) 1334 throws SQLException { 1335 // TODO Auto-generated method stub 1336 return query.getTimestamp(columnIndex, cal); 1337 } 1338 1339 @Override 1340 public Timestamp getTimestamp(int columnIndex) throws SQLException { 1341 // TODO Auto-generated method stub 1342 return query.getTimestamp(columnIndex); 1343 } 1344 1345 @Override 1346 public Timestamp getTimestamp(String columnName, Calendar cal) 1347 throws SQLException { 1348 // TODO Auto-generated method stub 1349 return query.getTimestamp(columnName, cal); 1350 } 1351 1352 @Override 1353 public Timestamp getTimestamp(String columnName) throws SQLException { 1354 // TODO Auto-generated method stub 1355 return query.getTimestamp(columnName); 1356 } 1357 1358 @Override 1359 public int getType() throws SQLException { 1360 // TODO Auto-generated method stub 1361 return query.getType(); 1362 } 1363 1364 @Override 1365 public InputStream getUnicodeStream(int columnIndex) throws SQLException { 1366 // TODO Auto-generated method stub 1367 return query.getUnicodeStream(columnIndex); 1368 } 1369 1370 @Override 1371 public InputStream getUnicodeStream(String columnName) throws SQLException { 1372 // TODO Auto-generated method stub 1373 return query.getUnicodeStream(columnName); 1374 } 1375 1376 @Override 1377 public int getUpdateCount() { 1378 // TODO Auto-generated method stub 1379 return query.getUpdateCount(); 1380 } 1381 1382 @Override 1383 public URL getURL(int columnIndex) throws SQLException { 1384 // TODO Auto-generated method stub 1385 return query.getURL(columnIndex); 1386 } 1387 1388 @Override 1389 public URL getURL(String columnName) throws SQLException { 1390 // TODO Auto-generated method stub 1391 return query.getURL(columnName); 1392 } 1393 1394 @Override 1395 public SQLWarning getWarnings() throws SQLException { 1396 // TODO Auto-generated method stub 1397 return query.getWarnings(); 1398 } 1399 1400 @Override 1401 public boolean isAfterLast() throws SQLException { 1402 // TODO Auto-generated method stub 1403 return query.isAfterLast(); 1404 } 1405 1406 @Override 1407 public boolean isBeforeFirst() throws SQLException { 1408 // TODO Auto-generated method stub 1409 return query.isBeforeFirst(); 1410 } 1411 1412 @Override 1413 public boolean isFirst() throws SQLException { 1414 // TODO Auto-generated method stub 1415 return query.isFirst(); 1416 } 1417 1418 @Override 1419 public boolean isLast() throws SQLException { 1420 // TODO Auto-generated method stub 1421 return query.isLast(); 1422 } 1423 1424 @Override 1425 public boolean last() throws SQLException { 1426 // TODO Auto-generated method stub 1427 return query.last(); 1428 } 1429 1430 @Override 1431 public void moveToCurrentRow() throws SQLException { 1432 // TODO Auto-generated method stub 1433 query.moveToCurrentRow(); 1434 } 1435 1436 @Override 1437 public void moveToInsertRow() throws SQLException { 1438 // TODO Auto-generated method stub 1439 query.moveToInsertRow(); 1440 } 1441 1442 @Override 1443 public boolean previous() { 1444 // TODO Auto-generated method stub 1445 return query.previous(); 1446 } 1447 1448 @Override 1449 public boolean previous(int pid) { 1450 // TODO Auto-generated method stub 1451 return query.previous(pid); 1452 } 1453 1454 @Override 1455 public void refreshRow() throws SQLException { 1456 // TODO Auto-generated method stub 1457 query.refreshRow(); 1458 } 1459 1460 @Override 1461 public boolean relative(int rows) throws SQLException { 1462 // TODO Auto-generated method stub 1463 return query.relative(rows); 1464 } 1465 1466 @Override 1467 public void setColumnNames(Collection.Key[] trg) throws PageException { 1468 // TODO Auto-generated method stub 1469 query.setColumnNames(trg); 1470 } 1471 1472 @Override 1473 public Iterator<Object> valueIterator() { 1474 // TODO Auto-generated method stub 1475 return query.valueIterator(); 1476 } 1477 1478 }