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