001 package railo.runtime.cfx; 002 003 004 import java.io.InputStream; 005 import java.io.Reader; 006 import java.math.BigDecimal; 007 import java.net.URL; 008 import java.sql.Array; 009 import java.sql.Blob; 010 import java.sql.Clob; 011 import java.sql.Date; 012 import java.sql.Ref; 013 import java.sql.ResultSetMetaData; 014 import java.sql.SQLException; 015 import java.sql.SQLWarning; 016 import java.sql.Statement; 017 import java.sql.Time; 018 import java.sql.Timestamp; 019 import java.util.Calendar; 020 import java.util.Iterator; 021 import java.util.Map; 022 023 024 //JDK6: uncomment this for compiling with JDK6 025 import java.sql.NClob; 026 import java.sql.RowId; 027 import java.sql.SQLXML; 028 029 030 import railo.runtime.PageContext; 031 import railo.runtime.dump.DumpData; 032 import railo.runtime.dump.DumpProperties; 033 import railo.runtime.exp.PageException; 034 import railo.runtime.type.Collection.Key; 035 036 import com.allaire.cfx.Query; 037 038 /** 039 * Implementation of the Query Interface 040 */ 041 public class QueryWrap implements Query { 042 043 044 private railo.runtime.type.Query rst; 045 private String name; 046 047 /** 048 * constructor of the class 049 * @param rst runtime Query 050 */ 051 public QueryWrap(railo.runtime.type.Query rst) { 052 this.rst=rst; 053 this.name=rst.getName(); 054 } 055 /** 056 * constructor of the class 057 * @param rst runtime Query 058 * @param name name of the query (otherwise rst.getName()) 059 */ 060 public QueryWrap(railo.runtime.type.Query rst, String name) { 061 this.rst=rst; 062 this.name=name; 063 } 064 065 /** 066 * @see com.allaire.cfx.Query#addRow() 067 */ 068 public int addRow() { 069 return rst.addRow(); 070 } 071 072 /** 073 * @see com.allaire.cfx.Query#getColumnIndex(java.lang.String) 074 */ 075 public int getColumnIndex(String coulmnName) { 076 return rst.getColumnIndex(coulmnName); 077 } 078 079 /** 080 * @see com.allaire.cfx.Query#getColumns() 081 */ 082 public String[] getColumns() { 083 return rst.getColumns(); 084 } 085 086 /* 087 FUTURE 088 public Collection.Key[] getColumnNames() { 089 return rst.getColumnNames(); 090 } 091 092 093 public String[] getColumnNamesAsString() { 094 return rst.getColumnNamesAsString(); 095 }*/ 096 097 /** 098 * @see com.allaire.cfx.Query#getData(int, int) 099 */ 100 public String getData(int row, int col) throws IndexOutOfBoundsException { 101 return rst.getData(row,col); 102 } 103 104 /** 105 * @see com.allaire.cfx.Query#getName() 106 */ 107 public String getName() { 108 return name; 109 } 110 111 /** 112 * @see com.allaire.cfx.Query#getRowCount() 113 */ 114 public int getRowCount() { 115 return rst.getRowCount(); 116 } 117 118 /** 119 * @see com.allaire.cfx.Query#setData(int, int, java.lang.String) 120 */ 121 public void setData(int row, int col, String value) throws IndexOutOfBoundsException { 122 rst.setData(row,col,value); 123 } 124 125 126 /** 127 * @see java.sql.ResultSet#absolute(int) 128 */ 129 public boolean absolute(int row) throws SQLException { 130 return rst.absolute(row); 131 } 132 /** 133 * @see java.sql.ResultSet#afterLast() 134 */ 135 public void afterLast() throws SQLException { 136 rst.afterLast(); 137 } 138 /** 139 * @see java.sql.ResultSet#beforeFirst() 140 */ 141 public void beforeFirst() throws SQLException { 142 rst.beforeFirst(); 143 } 144 /** 145 * @see java.sql.ResultSet#cancelRowUpdates() 146 */ 147 public void cancelRowUpdates() throws SQLException { 148 rst.cancelRowUpdates(); 149 } 150 /** 151 * @see java.sql.ResultSet#clearWarnings() 152 */ 153 public void clearWarnings() throws SQLException { 154 rst.clearWarnings(); 155 } 156 157 /** 158 * @see java.lang.Object#clone() 159 */ 160 public Object clone() { 161 return rst.clone(); 162 } 163 /** 164 * @see java.sql.ResultSet#close() 165 */ 166 public void close() throws SQLException { 167 rst.close(); 168 } 169 /** 170 * @see java.sql.ResultSet#deleteRow() 171 */ 172 public void deleteRow() throws SQLException { 173 rst.deleteRow(); 174 } 175 /** 176 * @see java.sql.ResultSet#findColumn(java.lang.String) 177 */ 178 public int findColumn(String columnName) throws SQLException { 179 return rst.findColumn(columnName); 180 } 181 /** 182 * @see java.sql.ResultSet#first() 183 */ 184 public boolean first() throws SQLException { 185 return rst.first(); 186 } 187 /** 188 * @see java.sql.ResultSet#getArray(int) 189 */ 190 public Array getArray(int i) throws SQLException { 191 return rst.getArray(i); 192 } 193 /** 194 * @see java.sql.ResultSet#getArray(java.lang.String) 195 */ 196 public Array getArray(String colName) throws SQLException { 197 return rst.getArray(colName); 198 } 199 /** 200 * @see java.sql.ResultSet#getAsciiStream(int) 201 */ 202 public InputStream getAsciiStream(int columnIndex) throws SQLException { 203 return rst.getAsciiStream(columnIndex); 204 } 205 /** 206 * @see java.sql.ResultSet#getAsciiStream(java.lang.String) 207 */ 208 public InputStream getAsciiStream(String columnName) throws SQLException { 209 return rst.getAsciiStream(columnName); 210 } 211 /** 212 * @see java.sql.ResultSet#getBigDecimal(int, int) 213 */ 214 public BigDecimal getBigDecimal(int columnIndex, int scale)throws SQLException { 215 return rst.getBigDecimal(columnIndex, scale); 216 } 217 /** 218 * @see java.sql.ResultSet#getBigDecimal(int) 219 */ 220 public BigDecimal getBigDecimal(int columnIndex) throws SQLException { 221 return rst.getBigDecimal(columnIndex); 222 } 223 /** 224 * @see java.sql.ResultSet#getBigDecimal(java.lang.String, int) 225 */ 226 public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException { 227 return rst.getBigDecimal(columnName, scale); 228 } 229 /** 230 * @see java.sql.ResultSet#getBigDecimal(java.lang.String) 231 */ 232 public BigDecimal getBigDecimal(String columnName) throws SQLException { 233 return rst.getBigDecimal(columnName); 234 } 235 /** 236 * @see java.sql.ResultSet#getBinaryStream(int) 237 */ 238 public InputStream getBinaryStream(int columnIndex) throws SQLException { 239 return rst.getBinaryStream(columnIndex); 240 } 241 /** 242 * @see java.sql.ResultSet#getBinaryStream(java.lang.String) 243 */ 244 public InputStream getBinaryStream(String columnName) throws SQLException { 245 return rst.getBinaryStream(columnName); 246 } 247 /** 248 * @see java.sql.ResultSet#getBlob(int) 249 */ 250 public Blob getBlob(int i) throws SQLException { 251 return rst.getBlob(i); 252 } 253 /** 254 * @see java.sql.ResultSet#getBlob(java.lang.String) 255 */ 256 public Blob getBlob(String colName) throws SQLException { 257 return rst.getBlob(colName); 258 } 259 /** 260 * @see java.sql.ResultSet#getBoolean(int) 261 */ 262 public boolean getBoolean(int columnIndex) throws SQLException { 263 return rst.getBoolean(columnIndex); 264 } 265 /** 266 * @see java.sql.ResultSet#getBoolean(java.lang.String) 267 */ 268 public boolean getBoolean(String columnName) throws SQLException { 269 return rst.getBoolean(columnName); 270 } 271 /** 272 * @see java.sql.ResultSet#getByte(int) 273 */ 274 public byte getByte(int columnIndex) throws SQLException { 275 return rst.getByte(columnIndex); 276 } 277 /** 278 * @see java.sql.ResultSet#getByte(java.lang.String) 279 */ 280 public byte getByte(String columnName) throws SQLException { 281 return rst.getByte(columnName); 282 } 283 /** 284 * @see java.sql.ResultSet#getBytes(int) 285 */ 286 public byte[] getBytes(int columnIndex) throws SQLException { 287 return rst.getBytes(columnIndex); 288 } 289 /** 290 * @see java.sql.ResultSet#getBytes(java.lang.String) 291 */ 292 public byte[] getBytes(String columnName) throws SQLException { 293 return rst.getBytes(columnName); 294 } 295 /** 296 * @see java.sql.ResultSet#getCharacterStream(int) 297 */ 298 public Reader getCharacterStream(int columnIndex) throws SQLException { 299 return rst.getCharacterStream(columnIndex); 300 } 301 /** 302 * @see java.sql.ResultSet#getCharacterStream(java.lang.String) 303 */ 304 public Reader getCharacterStream(String columnName) throws SQLException { 305 return rst.getCharacterStream(columnName); 306 } 307 /** 308 * @see java.sql.ResultSet#getClob(int) 309 */ 310 public Clob getClob(int i) throws SQLException { 311 return rst.getClob(i); 312 } 313 /** 314 * @see java.sql.ResultSet#getClob(java.lang.String) 315 */ 316 public Clob getClob(String colName) throws SQLException { 317 return rst.getClob(colName); 318 } 319 /** 320 * @see java.sql.ResultSet#getConcurrency() 321 */ 322 public int getConcurrency() throws SQLException { 323 return rst.getConcurrency(); 324 } 325 /** 326 * @see java.sql.ResultSet#getCursorName() 327 */ 328 public String getCursorName() throws SQLException { 329 return rst.getCursorName(); 330 } 331 /** 332 * @see java.sql.ResultSet#getDate(int, java.util.Calendar) 333 */ 334 public Date getDate(int columnIndex, Calendar cal) throws SQLException { 335 return rst.getDate(columnIndex, cal); 336 } 337 /** 338 * @see java.sql.ResultSet#getDate(int) 339 */ 340 public Date getDate(int columnIndex) throws SQLException { 341 return rst.getDate(columnIndex); 342 } 343 /** 344 * @see java.sql.ResultSet#getDate(java.lang.String, java.util.Calendar) 345 */ 346 public Date getDate(String columnName, Calendar cal) throws SQLException { 347 return rst.getDate(columnName, cal); 348 } 349 /** 350 * @see java.sql.ResultSet#getDate(java.lang.String) 351 */ 352 public Date getDate(String columnName) throws SQLException { 353 return rst.getDate(columnName); 354 } 355 /** 356 * @see java.sql.ResultSet#getDouble(int) 357 */ 358 public double getDouble(int columnIndex) throws SQLException { 359 return rst.getDouble(columnIndex); 360 } 361 /** 362 * @see java.sql.ResultSet#getDouble(java.lang.String) 363 */ 364 public double getDouble(String columnName) throws SQLException { 365 return rst.getDouble(columnName); 366 } 367 /** 368 * @see java.sql.ResultSet#getFetchDirection() 369 */ 370 public int getFetchDirection() throws SQLException { 371 return rst.getFetchDirection(); 372 } 373 /** 374 * @see java.sql.ResultSet#getFetchSize() 375 */ 376 public int getFetchSize() throws SQLException { 377 return rst.getFetchSize(); 378 } 379 /** 380 * @see java.sql.ResultSet#getFloat(int) 381 */ 382 public float getFloat(int columnIndex) throws SQLException { 383 return rst.getFloat(columnIndex); 384 } 385 /** 386 * @see java.sql.ResultSet#getFloat(java.lang.String) 387 */ 388 public float getFloat(String columnName) throws SQLException { 389 return rst.getFloat(columnName); 390 } 391 /** 392 * @see java.sql.ResultSet#getInt(int) 393 */ 394 public int getInt(int columnIndex) throws SQLException { 395 return rst.getInt(columnIndex); 396 } 397 /** 398 * @see java.sql.ResultSet#getInt(java.lang.String) 399 */ 400 public int getInt(String columnName) throws SQLException { 401 return rst.getInt(columnName); 402 } 403 /** 404 * @see java.sql.ResultSet#getLong(int) 405 */ 406 public long getLong(int columnIndex) throws SQLException { 407 return rst.getLong(columnIndex); 408 } 409 /** 410 * @see java.sql.ResultSet#getLong(java.lang.String) 411 */ 412 public long getLong(String columnName) throws SQLException { 413 return rst.getLong(columnName); 414 } 415 /** 416 * @see java.sql.ResultSet#getMetaData() 417 */ 418 public ResultSetMetaData getMetaData() throws SQLException { 419 return rst.getMetaData(); 420 } 421 /** 422 * @see java.sql.ResultSet#getObject(int, java.util.Map) 423 */ 424 public Object getObject(int i, Map map) throws SQLException { 425 return rst.getObject(i, map); 426 } 427 /** 428 * @see java.sql.ResultSet#getObject(int) 429 */ 430 public Object getObject(int columnIndex) throws SQLException { 431 return rst.getObject(columnIndex); 432 } 433 /** 434 * @see java.sql.ResultSet#getObject(java.lang.String, java.util.Map) 435 */ 436 public Object getObject(String colName, Map map) throws SQLException { 437 return rst.getObject(colName, map); 438 } 439 /** 440 * @see java.sql.ResultSet#getObject(java.lang.String) 441 */ 442 public Object getObject(String columnName) throws SQLException { 443 return rst.getObject(columnName); 444 } 445 /** 446 * @return recordcount of the query 447 */ 448 public int getRecordcount() { 449 return rst.getRecordcount(); 450 } 451 /** 452 * @see java.sql.ResultSet#getRef(int) 453 */ 454 public Ref getRef(int i) throws SQLException { 455 return rst.getRef(i); 456 } 457 /** 458 * @see java.sql.ResultSet#getRef(java.lang.String) 459 */ 460 public Ref getRef(String colName) throws SQLException { 461 return rst.getRef(colName); 462 } 463 /** 464 * @see java.sql.ResultSet#getRow() 465 */ 466 public int getRow() throws SQLException { 467 return rst.getRow(); 468 } 469 /** 470 * @see java.sql.ResultSet#getShort(int) 471 */ 472 public short getShort(int columnIndex) throws SQLException { 473 return rst.getShort(columnIndex); 474 } 475 /** 476 * @see java.sql.ResultSet#getShort(java.lang.String) 477 */ 478 public short getShort(String columnName) throws SQLException { 479 return rst.getShort(columnName); 480 } 481 /** 482 * @see java.sql.ResultSet#getStatement() 483 */ 484 public Statement getStatement() throws SQLException { 485 return rst.getStatement(); 486 } 487 /** 488 * @see java.sql.ResultSet#getString(int) 489 */ 490 public String getString(int columnIndex) throws SQLException { 491 return rst.getString(columnIndex); 492 } 493 /** 494 * @see java.sql.ResultSet#getString(java.lang.String) 495 */ 496 public String getString(String columnName) throws SQLException { 497 return rst.getString(columnName); 498 } 499 /** 500 * @see java.sql.ResultSet#getTime(int, java.util.Calendar) 501 */ 502 public Time getTime(int columnIndex, Calendar cal) throws SQLException { 503 return rst.getTime(columnIndex, cal); 504 } 505 /** 506 * @see java.sql.ResultSet#getTime(int) 507 */ 508 public Time getTime(int columnIndex) throws SQLException { 509 return rst.getTime(columnIndex); 510 } 511 /** 512 * @see java.sql.ResultSet#getTime(java.lang.String, java.util.Calendar) 513 */ 514 public Time getTime(String columnName, Calendar cal) throws SQLException { 515 return rst.getTime(columnName, cal); 516 } 517 /** 518 * @see java.sql.ResultSet#getTime(java.lang.String) 519 */ 520 public Time getTime(String columnName) throws SQLException { 521 return rst.getTime(columnName); 522 } 523 /** 524 * @see java.sql.ResultSet#getTimestamp(int, java.util.Calendar) 525 */ 526 public Timestamp getTimestamp(int columnIndex, Calendar cal)throws SQLException { 527 return rst.getTimestamp(columnIndex, cal); 528 } 529 /** 530 * @see java.sql.ResultSet#getTimestamp(int) 531 */ 532 public Timestamp getTimestamp(int columnIndex) throws SQLException { 533 return rst.getTimestamp(columnIndex); 534 } 535 /** 536 * @see java.sql.ResultSet#getTimestamp(java.lang.String, java.util.Calendar) 537 */ 538 public Timestamp getTimestamp(String columnName, Calendar cal) 539 throws SQLException { 540 return rst.getTimestamp(columnName, cal); 541 } 542 /** 543 * @see java.sql.ResultSet#getTimestamp(java.lang.String) 544 */ 545 public Timestamp getTimestamp(String columnName) throws SQLException { 546 return rst.getTimestamp(columnName); 547 } 548 /** 549 * @see java.sql.ResultSet#getType() 550 */ 551 public int getType() throws SQLException { 552 return rst.getType(); 553 } 554 /** 555 * @see java.sql.ResultSet#getUnicodeStream(int) 556 */ 557 public InputStream getUnicodeStream(int columnIndex) throws SQLException { 558 return rst.getUnicodeStream(columnIndex); 559 } 560 /** 561 * @see java.sql.ResultSet#getUnicodeStream(java.lang.String) 562 */ 563 public InputStream getUnicodeStream(String columnName) throws SQLException { 564 return rst.getUnicodeStream(columnName); 565 } 566 /** 567 * @see java.sql.ResultSet#getURL(int) 568 */ 569 public URL getURL(int columnIndex) throws SQLException { 570 return rst.getURL(columnIndex); 571 } 572 /** 573 * @see java.sql.ResultSet#getURL(java.lang.String) 574 */ 575 public URL getURL(String columnName) throws SQLException { 576 return rst.getURL(columnName); 577 } 578 /** 579 * @see java.sql.ResultSet#getWarnings() 580 */ 581 public SQLWarning getWarnings() throws SQLException { 582 return rst.getWarnings(); 583 } 584 /** 585 * @see java.sql.ResultSet#insertRow() 586 */ 587 public void insertRow() throws SQLException { 588 rst.insertRow(); 589 } 590 /** 591 * @see java.sql.ResultSet#isAfterLast() 592 */ 593 public boolean isAfterLast() throws SQLException { 594 595 return rst.isAfterLast(); 596 } 597 /** 598 * @see java.sql.ResultSet#isBeforeFirst() 599 */ 600 public boolean isBeforeFirst() throws SQLException { 601 return rst.isBeforeFirst(); 602 } 603 /** 604 * @return is cached 605 */ 606 public boolean isCached() { 607 return rst.isCached(); 608 } 609 /** 610 * @return has records 611 */ 612 public boolean isEmpty() { 613 return rst.isEmpty(); 614 } 615 /** 616 * @see java.sql.ResultSet#isFirst() 617 */ 618 public boolean isFirst() throws SQLException { 619 return rst.isFirst(); 620 } 621 /** 622 * @see java.sql.ResultSet#isLast() 623 */ 624 public boolean isLast() throws SQLException { 625 return rst.isLast(); 626 } 627 /** 628 * @return iterator for he keys 629 */ 630 public Iterator keyIterator() { 631 return rst.keyIterator(); 632 } 633 /** 634 * @return all keys of the Query 635 */ 636 public Key[] keys() { 637 return rst.keys(); 638 } 639 /** 640 * @see java.sql.ResultSet#last() 641 */ 642 public boolean last() throws SQLException { 643 644 return rst.last(); 645 } 646 647 648 649 /** 650 * @see java.sql.ResultSet#moveToCurrentRow() 651 */ 652 public void moveToCurrentRow() throws SQLException { 653 rst.moveToCurrentRow(); 654 } 655 /** 656 * @see java.sql.ResultSet#moveToInsertRow() 657 */ 658 public void moveToInsertRow() throws SQLException { 659 rst.moveToInsertRow(); 660 } 661 /** 662 * @see java.sql.ResultSet#next() 663 */ 664 public boolean next() { 665 return rst.next(); 666 } 667 /** 668 * @see java.sql.ResultSet#previous() 669 */ 670 public boolean previous() throws SQLException{ 671 return rst.previous(); 672 } 673 /** 674 * @see java.sql.ResultSet#refreshRow() 675 */ 676 public void refreshRow() throws SQLException { 677 rst.refreshRow(); 678 } 679 /** 680 * @see java.sql.ResultSet#relative(int) 681 */ 682 public boolean relative(int rows) throws SQLException { 683 return rst.relative(rows); 684 } 685 /** 686 * @see java.sql.ResultSet#rowDeleted() 687 */ 688 public boolean rowDeleted() throws SQLException { 689 return rst.rowDeleted(); 690 } 691 /** 692 * @see java.sql.ResultSet#rowInserted() 693 */ 694 public boolean rowInserted() throws SQLException { 695 return rst.rowInserted(); 696 } 697 /** 698 * @see java.sql.ResultSet#rowUpdated() 699 */ 700 public boolean rowUpdated() throws SQLException { 701 return rst.rowUpdated(); 702 } 703 704 /** 705 * @see java.sql.ResultSet#setFetchDirection(int) 706 */ 707 public void setFetchDirection(int direction) throws SQLException { 708 rst.setFetchDirection(direction); 709 } 710 /** 711 * @see java.sql.ResultSet#setFetchSize(int) 712 */ 713 public void setFetchSize(int rows) throws SQLException { 714 rst.setFetchSize(rows); 715 } 716 717 /** 718 * @return the size of the query 719 */ 720 public int size() { 721 return rst.size(); 722 } 723 /** 724 * @param keyColumn 725 * @param order 726 * @throws PageException 727 */ 728 public synchronized void sort(Key keyColumn, int order) 729 throws PageException { 730 731 rst.sort(keyColumn, order); 732 } 733 /** 734 * @param column 735 * @throws PageException 736 */ 737 public void sort(Key column) throws PageException { 738 739 rst.sort(column); 740 } 741 /** 742 * @param strColumn 743 * @param order 744 * @throws PageException 745 */ 746 public synchronized void sort(String strColumn, int order) 747 throws PageException { 748 749 rst.sort(strColumn, order); 750 } 751 /** 752 * @param column 753 * @throws PageException 754 */ 755 public void sort(String column) throws PageException { 756 757 rst.sort(column); 758 } 759 /** 760 * @param pageContext 761 * @param maxlevel 762 * @param dp 763 * @return generated DumpData 764 */ 765 public DumpData toDumpData(PageContext pageContext, int maxlevel,DumpProperties dp) { 766 return rst.toDumpData(pageContext, maxlevel, dp); 767 } 768 /** 769 * @see java.lang.Object#toString() 770 */ 771 public String toString() { 772 return rst.toString(); 773 } 774 /** 775 * @see java.sql.ResultSet#updateArray(int, java.sql.Array) 776 */ 777 public void updateArray(int columnIndex, Array x) throws SQLException { 778 rst.updateArray(columnIndex, x); 779 } 780 /** 781 * @see java.sql.ResultSet#updateArray(java.lang.String, java.sql.Array) 782 */ 783 public void updateArray(String columnName, Array x) throws SQLException { 784 rst.updateArray(columnName, x); 785 } 786 /** 787 * @see java.sql.ResultSet#updateAsciiStream(int, java.io.InputStream, int) 788 */ 789 public void updateAsciiStream(int columnIndex, InputStream x, int length) 790 throws SQLException { 791 rst.updateAsciiStream(columnIndex, x, length); 792 } 793 /** 794 * @see java.sql.ResultSet#updateAsciiStream(java.lang.String, java.io.InputStream, int) 795 */ 796 public void updateAsciiStream(String columnName, InputStream x, int length) 797 throws SQLException { 798 799 rst.updateAsciiStream(columnName, x, length); 800 } 801 /** 802 * @see java.sql.ResultSet#updateBigDecimal(int, java.math.BigDecimal) 803 */ 804 public void updateBigDecimal(int columnIndex, BigDecimal x) 805 throws SQLException { 806 807 rst.updateBigDecimal(columnIndex, x); 808 } 809 /** 810 * @see java.sql.ResultSet#updateBigDecimal(java.lang.String, java.math.BigDecimal) 811 */ 812 public void updateBigDecimal(String columnName, BigDecimal x) 813 throws SQLException { 814 815 rst.updateBigDecimal(columnName, x); 816 } 817 /** 818 * @see java.sql.ResultSet#updateBinaryStream(int, java.io.InputStream, int) 819 */ 820 public void updateBinaryStream(int columnIndex, InputStream x, int length) 821 throws SQLException { 822 823 rst.updateBinaryStream(columnIndex, x, length); 824 } 825 /** 826 * @see java.sql.ResultSet#updateBinaryStream(java.lang.String, java.io.InputStream, int) 827 */ 828 public void updateBinaryStream(String columnName, InputStream x, int length) 829 throws SQLException { 830 831 rst.updateBinaryStream(columnName, x, length); 832 } 833 /** 834 * @see java.sql.ResultSet#updateBlob(int, java.sql.Blob) 835 */ 836 public void updateBlob(int columnIndex, Blob x) throws SQLException { 837 838 rst.updateBlob(columnIndex, x); 839 } 840 /** 841 * @see java.sql.ResultSet#updateBlob(java.lang.String, java.sql.Blob) 842 */ 843 public void updateBlob(String columnName, Blob x) throws SQLException { 844 845 rst.updateBlob(columnName, x); 846 } 847 /** 848 * @see java.sql.ResultSet#updateBoolean(int, boolean) 849 */ 850 public void updateBoolean(int columnIndex, boolean x) throws SQLException { 851 852 rst.updateBoolean(columnIndex, x); 853 } 854 /** 855 * @see java.sql.ResultSet#updateBoolean(java.lang.String, boolean) 856 */ 857 public void updateBoolean(String columnName, boolean x) throws SQLException { 858 859 rst.updateBoolean(columnName, x); 860 } 861 /** 862 * @see java.sql.ResultSet#updateByte(int, byte) 863 */ 864 public void updateByte(int columnIndex, byte x) throws SQLException { 865 866 rst.updateByte(columnIndex, x); 867 } 868 /** 869 * @see java.sql.ResultSet#updateByte(java.lang.String, byte) 870 */ 871 public void updateByte(String columnName, byte x) throws SQLException { 872 873 rst.updateByte(columnName, x); 874 } 875 /** 876 * @see java.sql.ResultSet#updateBytes(int, byte[]) 877 */ 878 public void updateBytes(int columnIndex, byte[] x) throws SQLException { 879 880 rst.updateBytes(columnIndex, x); 881 } 882 /** 883 * @see java.sql.ResultSet#updateBytes(java.lang.String, byte[]) 884 */ 885 public void updateBytes(String columnName, byte[] x) throws SQLException { 886 rst.updateBytes(columnName, x); 887 } 888 /** 889 * @see java.sql.ResultSet#updateCharacterStream(int, java.io.Reader, int) 890 */ 891 public void updateCharacterStream(int columnIndex, Reader reader, int length) 892 throws SQLException { 893 894 rst.updateCharacterStream(columnIndex, reader, length); 895 } 896 /** 897 * @see java.sql.ResultSet#updateCharacterStream(java.lang.String, java.io.Reader, int) 898 */ 899 public void updateCharacterStream(String columnName, Reader reader, 900 int length) throws SQLException { 901 rst.updateCharacterStream(columnName, reader, length); 902 } 903 /** 904 * @see java.sql.ResultSet#updateClob(int, java.sql.Clob) 905 */ 906 public void updateClob(int columnIndex, Clob x) throws SQLException { 907 rst.updateClob(columnIndex, x); 908 } 909 /** 910 * @see java.sql.ResultSet#updateClob(java.lang.String, java.sql.Clob) 911 */ 912 public void updateClob(String columnName, Clob x) throws SQLException { 913 rst.updateClob(columnName, x); 914 } 915 /** 916 * @see java.sql.ResultSet#updateDate(int, java.sql.Date) 917 */ 918 public void updateDate(int columnIndex, Date x) throws SQLException { 919 rst.updateDate(columnIndex, x); 920 } 921 /** 922 * @see java.sql.ResultSet#updateDate(java.lang.String, java.sql.Date) 923 */ 924 public void updateDate(String columnName, Date x) throws SQLException { 925 rst.updateDate(columnName, x); 926 } 927 /** 928 * @see java.sql.ResultSet#updateDouble(int, double) 929 */ 930 public void updateDouble(int columnIndex, double x) throws SQLException { 931 rst.updateDouble(columnIndex, x); 932 } 933 /** 934 * @see java.sql.ResultSet#updateDouble(java.lang.String, double) 935 */ 936 public void updateDouble(String columnName, double x) throws SQLException { 937 rst.updateDouble(columnName, x); 938 } 939 /** 940 * @see java.sql.ResultSet#updateFloat(int, float) 941 */ 942 public void updateFloat(int columnIndex, float x) throws SQLException { 943 rst.updateFloat(columnIndex, x); 944 } 945 /** 946 * @see java.sql.ResultSet#updateFloat(java.lang.String, float) 947 */ 948 public void updateFloat(String columnName, float x) throws SQLException { 949 rst.updateFloat(columnName, x); 950 } 951 /** 952 * @see java.sql.ResultSet#updateInt(int, int) 953 */ 954 public void updateInt(int columnIndex, int x) throws SQLException { 955 rst.updateInt(columnIndex, x); 956 } 957 /** 958 * @see java.sql.ResultSet#updateInt(java.lang.String, int) 959 */ 960 public void updateInt(String columnName, int x) throws SQLException { 961 rst.updateInt(columnName, x); 962 } 963 /** 964 * @see java.sql.ResultSet#updateLong(int, long) 965 */ 966 public void updateLong(int columnIndex, long x) throws SQLException { 967 rst.updateLong(columnIndex, x); 968 } 969 /** 970 * @see java.sql.ResultSet#updateLong(java.lang.String, long) 971 */ 972 public void updateLong(String columnName, long x) throws SQLException { 973 rst.updateLong(columnName, x); 974 } 975 /** 976 * @see java.sql.ResultSet#updateNull(int) 977 */ 978 public void updateNull(int columnIndex) throws SQLException { 979 rst.updateNull(columnIndex); 980 } 981 /** 982 * @see java.sql.ResultSet#updateNull(java.lang.String) 983 */ 984 public void updateNull(String columnName) throws SQLException { 985 rst.updateNull(columnName); 986 } 987 /** 988 * @see java.sql.ResultSet#updateObject(int, java.lang.Object, int) 989 */ 990 public void updateObject(int columnIndex, Object x, int scale) 991 throws SQLException { 992 rst.updateObject(columnIndex, x, scale); 993 } 994 /** 995 * @see java.sql.ResultSet#updateObject(int, java.lang.Object) 996 */ 997 public void updateObject(int columnIndex, Object x) throws SQLException { 998 rst.updateObject(columnIndex, x); 999 } 1000 /** 1001 * @see java.sql.ResultSet#updateObject(java.lang.String, java.lang.Object, int) 1002 */ 1003 public void updateObject(String columnName, Object x, int scale) 1004 throws SQLException { 1005 rst.updateObject(columnName, x, scale); 1006 } 1007 /** 1008 * @see java.sql.ResultSet#updateObject(java.lang.String, java.lang.Object) 1009 */ 1010 public void updateObject(String columnName, Object x) throws SQLException { 1011 rst.updateObject(columnName, x); 1012 } 1013 /** 1014 * @see java.sql.ResultSet#updateRef(int, java.sql.Ref) 1015 */ 1016 public void updateRef(int columnIndex, Ref x) throws SQLException { 1017 rst.updateRef(columnIndex, x); 1018 } 1019 /** 1020 * @see java.sql.ResultSet#updateRef(java.lang.String, java.sql.Ref) 1021 */ 1022 public void updateRef(String columnName, Ref x) throws SQLException { 1023 rst.updateRef(columnName, x); 1024 } 1025 /** 1026 * @see java.sql.ResultSet#updateRow() 1027 */ 1028 public void updateRow() throws SQLException { 1029 rst.updateRow(); 1030 } 1031 /** 1032 * @see java.sql.ResultSet#updateShort(int, short) 1033 */ 1034 public void updateShort(int columnIndex, short x) throws SQLException { 1035 rst.updateShort(columnIndex, x); 1036 } 1037 /** 1038 * @see java.sql.ResultSet#updateShort(java.lang.String, short) 1039 */ 1040 public void updateShort(String columnName, short x) throws SQLException { 1041 rst.updateShort(columnName, x); 1042 } 1043 /** 1044 * @see java.sql.ResultSet#updateString(int, java.lang.String) 1045 */ 1046 public void updateString(int columnIndex, String x) throws SQLException { 1047 rst.updateString(columnIndex, x); 1048 } 1049 /** 1050 * @see java.sql.ResultSet#updateString(java.lang.String, java.lang.String) 1051 */ 1052 public void updateString(String columnName, String x) throws SQLException { 1053 rst.updateString(columnName, x); 1054 } 1055 /** 1056 * @see java.sql.ResultSet#updateTime(int, java.sql.Time) 1057 */ 1058 public void updateTime(int columnIndex, Time x) throws SQLException { 1059 rst.updateTime(columnIndex, x); 1060 } 1061 /** 1062 * @see java.sql.ResultSet#updateTime(java.lang.String, java.sql.Time) 1063 */ 1064 public void updateTime(String columnName, Time x) throws SQLException { 1065 rst.updateTime(columnName, x); 1066 } 1067 /** 1068 * @see java.sql.ResultSet#updateTimestamp(int, java.sql.Timestamp) 1069 */ 1070 public void updateTimestamp(int columnIndex, Timestamp x) 1071 throws SQLException { 1072 rst.updateTimestamp(columnIndex, x); 1073 } 1074 /** 1075 * @see java.sql.ResultSet#updateTimestamp(java.lang.String, java.sql.Timestamp) 1076 */ 1077 public void updateTimestamp(String columnName, Timestamp x) 1078 throws SQLException { 1079 rst.updateTimestamp(columnName, x); 1080 } 1081 /** 1082 * @see java.sql.ResultSet#wasNull() 1083 */ 1084 public boolean wasNull() throws SQLException{ 1085 return rst.wasNull(); 1086 } 1087 public railo.runtime.type.Query getQuery() { 1088 return rst; 1089 } 1090 public int getHoldability() throws SQLException { 1091 throw notSupported(); 1092 } 1093 public Reader getNCharacterStream(int arg0) throws SQLException { 1094 throw notSupported(); 1095 } 1096 public Reader getNCharacterStream(String arg0) throws SQLException { 1097 throw notSupported(); 1098 } 1099 public String getNString(int arg0) throws SQLException { 1100 throw notSupported(); 1101 } 1102 public String getNString(String arg0) throws SQLException { 1103 throw notSupported(); 1104 } 1105 public boolean isClosed() throws SQLException { 1106 throw notSupported(); 1107 } 1108 public void updateAsciiStream(int arg0, InputStream arg1)throws SQLException { 1109 throw notSupported(); 1110 } 1111 public void updateAsciiStream(String arg0, InputStream arg1)throws SQLException { 1112 throw notSupported(); 1113 } 1114 public void updateAsciiStream(int arg0, InputStream arg1, long arg2) 1115 throws SQLException { 1116 throw notSupported(); 1117 } 1118 public void updateAsciiStream(String arg0, InputStream arg1, long arg2) 1119 throws SQLException { 1120 throw notSupported(); 1121 } 1122 public void updateBinaryStream(int arg0, InputStream arg1) 1123 throws SQLException { 1124 throw notSupported(); 1125 } 1126 public void updateBinaryStream(String arg0, InputStream arg1) 1127 throws SQLException { 1128 throw notSupported(); 1129 } 1130 public void updateBinaryStream(int arg0, InputStream arg1, long arg2) 1131 throws SQLException { 1132 throw notSupported(); 1133 } 1134 public void updateBinaryStream(String arg0, InputStream arg1, long arg2) 1135 throws SQLException { 1136 throw notSupported(); 1137 } 1138 public void updateBlob(int arg0, InputStream arg1) throws SQLException { 1139 throw notSupported(); 1140 } 1141 public void updateBlob(String arg0, InputStream arg1) throws SQLException { 1142 throw notSupported(); 1143 } 1144 public void updateBlob(int arg0, InputStream arg1, long arg2) 1145 throws SQLException { 1146 throw notSupported(); 1147 } 1148 public void updateBlob(String arg0, InputStream arg1, long arg2) 1149 throws SQLException { 1150 throw notSupported(); 1151 } 1152 public void updateCharacterStream(int arg0, Reader arg1) 1153 throws SQLException { 1154 throw notSupported(); 1155 } 1156 public void updateCharacterStream(String arg0, Reader arg1) 1157 throws SQLException { 1158 throw notSupported(); 1159 } 1160 public void updateCharacterStream(int arg0, Reader arg1, long arg2) 1161 throws SQLException { 1162 throw notSupported(); 1163 } 1164 public void updateCharacterStream(String arg0, Reader arg1, long arg2) 1165 throws SQLException { 1166 throw notSupported(); 1167 } 1168 public void updateClob(int arg0, Reader arg1) throws SQLException { 1169 throw notSupported(); 1170 } 1171 public void updateClob(String arg0, Reader arg1) throws SQLException { 1172 throw notSupported(); 1173 } 1174 public void updateClob(int arg0, Reader arg1, long arg2) 1175 throws SQLException { 1176 throw notSupported(); 1177 } 1178 public void updateClob(String arg0, Reader arg1, long arg2) 1179 throws SQLException { 1180 throw notSupported(); 1181 } 1182 public void updateNCharacterStream(int arg0, Reader arg1) 1183 throws SQLException { 1184 throw notSupported(); 1185 } 1186 public void updateNCharacterStream(String arg0, Reader arg1) 1187 throws SQLException { 1188 throw notSupported(); 1189 } 1190 public void updateNCharacterStream(int arg0, Reader arg1, long arg2) 1191 throws SQLException { 1192 throw notSupported(); 1193 } 1194 public void updateNCharacterStream(String arg0, Reader arg1, long arg2) 1195 throws SQLException { 1196 throw notSupported(); 1197 } 1198 public void updateNClob(int arg0, Reader arg1) throws SQLException { 1199 throw notSupported(); 1200 } 1201 public void updateNClob(String arg0, Reader arg1) throws SQLException { 1202 throw notSupported(); 1203 } 1204 public void updateNClob(int arg0, Reader arg1, long arg2) 1205 throws SQLException { 1206 throw notSupported(); 1207 } 1208 public void updateNClob(String arg0, Reader arg1, long arg2) 1209 throws SQLException { 1210 throw notSupported(); 1211 } 1212 public void updateNString(int arg0, String arg1) throws SQLException { 1213 throw notSupported(); 1214 } 1215 public void updateNString(String arg0, String arg1) throws SQLException { 1216 throw notSupported(); 1217 } 1218 public boolean isWrapperFor(Class<?> arg0) throws SQLException { 1219 throw notSupported(); 1220 } 1221 public <T> T unwrap(Class<T> arg0) throws SQLException { 1222 throw notSupported(); 1223 } 1224 1225 //JDK6: uncomment this for compiling with JDK6 1226 public NClob getNClob(int arg0) throws SQLException { 1227 return rst.getNClob(arg0); 1228 } 1229 public NClob getNClob(String arg0) throws SQLException { 1230 return rst.getNClob(arg0); 1231 } 1232 public RowId getRowId(int arg0) throws SQLException { 1233 return rst.getRowId(arg0); 1234 } 1235 public RowId getRowId(String arg0) throws SQLException { 1236 return rst.getRowId(arg0); 1237 } 1238 public SQLXML getSQLXML(int arg0) throws SQLException { 1239 return rst.getSQLXML(arg0); 1240 } 1241 public SQLXML getSQLXML(String arg0) throws SQLException { 1242 return rst.getSQLXML(arg0); 1243 } 1244 public void updateNClob(int arg0, NClob arg1) throws SQLException { 1245 rst.updateNClob(arg0, arg1); 1246 } 1247 public void updateNClob(String arg0, NClob arg1) throws SQLException { 1248 rst.updateNClob(arg0, arg1); 1249 } 1250 public void updateRowId(int arg0, RowId arg1) throws SQLException { 1251 rst.updateRowId(arg0, arg1); 1252 } 1253 public void updateRowId(String arg0, RowId arg1) throws SQLException { 1254 rst.updateRowId(arg0, arg1); 1255 } 1256 public void updateSQLXML(int arg0, SQLXML arg1) throws SQLException { 1257 rst.updateSQLXML(arg0, arg1); 1258 } 1259 public void updateSQLXML(String arg0, SQLXML arg1) throws SQLException { 1260 rst.updateSQLXML(arg0, arg1); 1261 } 1262 1263 1264 1265 1266 1267 1268 1269 private SQLException notSupported() { 1270 return new SQLException("this feature is not supported"); 1271 } 1272 private RuntimeException notSupportedEL() { 1273 return new RuntimeException(new SQLException("this feature is not supported")); 1274 } 1275 }