View Javadoc
1 // 2 // Copyright 1999 Craig Spannring 3 // 4 // All rights reserved. 5 // 6 // Redistribution and use in source and binary forms, with or without 7 // modification, are permitted provided that the following conditions are met: 8 // 1. Redistributions of source code must retain the above copyright 9 // notice, this list of conditions and the following disclaimer. 10 // 2. Redistributions in binary form must reproduce the above copyright 11 // notice, this list of conditions and the following disclaimer in the 12 // documentation and/or other materials provided with the distribution. 13 // 3. All advertising materials mentioning features or use of this software 14 // must display the following acknowledgement: 15 // This product includes software developed by Craig Spannring 16 // 4. The name of Craig Spannring may not be used to endorse or promote 17 // products derived from this software without specific prior 18 // written permission. 19 // 20 // THIS SOFTWARE IS PROVIDED BY CRAIG SPANNRING ``AS IS'' AND 21 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 // ARE DISCLAIMED. IN NO EVENT SHALL CRAIG SPANNRING BE LIABLE 24 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 // OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 // HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 // OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 // SUCH DAMAGE. 31 // 32 33 34 package com.internetcds.jdbc.tds; 35 36 37 import java.sql.*; 38 import java.math.BigDecimal; 39 import java.util.Vector; 40 // import java.util.Calendar; 41 import java.util.GregorianCalendar; 42 import java.util.Calendar; 43 import java.net.URL; 44 45 46 47 public class ResultSet_2_0 48 extends com.internetcds.jdbc.tds.ResultSet_base 49 implements java.sql.ResultSet 50 { 51 public static final String cvsVersion = "$Id: ResultSet_2_0.java,v 1.1 2007/07/18 07:31:06 dejan Exp $"; 52 53 54 public ResultSet_2_0(Tds tds_, 55 com.internetcds.jdbc.tds.Statement stmt_, 56 Columns columns_) 57 { 58 super(tds_, stmt_, columns_); 59 } 60 61 62 //--------------------------------------------------------------------- 63 // Getter's and Setter's 64 //--------------------------------------------------------------------- 65 66 /*** 67 * JDBC 2.0 68 * 69 * <p>Gets the value of a column in the current row as a java.io.Reader. 70 * @param columnIndex the first column is 1, the second is 2, ... 71 */ 72 public java.io.Reader getCharacterStream(int columnIndex) throws SQLException 73 { 74 String val = getString(columnIndex); 75 if (val == null) 76 return null; 77 78 return new java.io.StringReader(val); 79 } 80 81 82 /*** 83 * JDBC 2.0 84 * 85 * <p>Gets the value of a column in the current row as a java.io.Reader. 86 * @param columnName the name of the column 87 * @return the value in the specified column as a <code>java.io.Reader</code> 88 */ 89 public java.io.Reader getCharacterStream(String columnName) throws SQLException 90 { 91 return getCharacterStream(findColumn(columnName)); 92 } 93 94 95 /*** 96 * JDBC 2.0 97 * 98 * Gets the value of a column in the current row as a java.math.BigDecimal 99 * object with full precision. 100 * 101 * @param columnIndex the first column is 1, the second is 2, ... 102 * @return the column value (full precision); if the value is SQL NULL, 103 * the result is null 104 * @exception SQLException if a database access error occurs 105 */ 106 public BigDecimal getBigDecimal(int columnIndex) throws SQLException 107 { 108 return getBigDecimal(columnIndex, 0); 109 // NotImplemented(); 110 // return null; 111 } 112 113 114 /*** 115 * JDBC 2.0 116 * 117 * Gets the value of a column in the current row as a java.math.BigDecimal 118 * object with full precision. 119 * @param columnName the column name 120 * @return the column value (full precision); if the value is SQL NULL, 121 * the result is null 122 * @exception SQLException if a database access error occurs 123 * 124 */ 125 public BigDecimal getBigDecimal(String columnName) throws SQLException 126 { 127 128 return getBigDecimal(findColumn(columnName), 0); 129 // NotImplemented(); 130 // return null; 131 } 132 133 134 //--------------------------------------------------------------------- 135 // Traversal/Positioning 136 //--------------------------------------------------------------------- 137 138 /*** 139 * JDBC 2.0 140 * 141 * <p>Indicates whether the cursor is before the first row in the result 142 * set. 143 * 144 * @return true if the cursor is before the first row, 145 * false otherwise. Returns 146 * false when the result set contains no rows. 147 * @exception SQLException if a database access error occurs 148 */ 149 public boolean isBeforeFirst() throws SQLException 150 { 151 NotImplemented(); 152 return false; 153 } 154 155 156 /*** 157 * JDBC 2.0 158 * 159 * <p>Indicates whether the cursor is after the last row in the result 160 * set. 161 * 162 * @return true if the cursor is after the last row, false otherwise. Returns 163 * false when the result set contains no rows. 164 * @exception SQLException if a database access error occurs 165 */ 166 public boolean isAfterLast() throws SQLException 167 { 168 NotImplemented(); 169 return false; 170 } 171 172 173 /*** 174 * JDBC 2.0 175 * 176 * <p>Indicates whether the cursor is on the first row of the result set. 177 * 178 * @return true if the cursor is on the first row, false otherwise. 179 * @exception SQLException if a database access error occurs 180 */ 181 public boolean isFirst() throws SQLException 182 { 183 NotImplemented(); 184 return false; 185 } 186 187 188 /*** 189 * JDBC 2.0 190 * 191 * <p>Indicates whether the cursor is on the last row of the result set. 192 * Note: Calling the method <code>isLast</code> may be expensive 193 * because the JDBC driver 194 * might need to fetch ahead one row in order to determine 195 * whether the current row is the last row in the result set. 196 * 197 * @return true if the cursor is on the last row, false otherwise. 198 * @exception SQLException if a database access error occurs 199 */ 200 public boolean isLast() throws SQLException 201 { 202 NotImplemented(); 203 return false; 204 } 205 206 207 /*** 208 * JDBC 2.0 209 * 210 * <p>Moves the cursor to the front of the result set, just before the 211 * first row. Has no effect if the result set contains no rows. 212 * 213 * @exception SQLException if a database access error occurs or the 214 * result set type is TYPE_FORWARD_ONLY 215 */ 216 public void beforeFirst() throws SQLException 217 { 218 NotImplemented(); 219 } 220 221 222 /*** 223 * JDBC 2.0 224 * 225 * <p>Moves the cursor to the end of the result set, just after the last 226 * row. Has no effect if the result set contains no rows. 227 * 228 * @exception SQLException if a database access error occurs or the 229 * result set type is TYPE_FORWARD_ONLY 230 */ 231 public void afterLast() throws SQLException 232 { 233 NotImplemented(); 234 } 235 236 237 /*** 238 * JDBC 2.0 239 * 240 * <p>Moves the cursor to the first row in the result set. 241 * 242 * @return true if the cursor is on a valid row; false if 243 * there are no rows in the result set 244 * @exception SQLException if a database access error occurs or the 245 * result set type is TYPE_FORWARD_ONLY 246 */ 247 public boolean first() throws SQLException 248 { 249 NotImplemented(); 250 return false; 251 } 252 253 254 /*** 255 * JDBC 2.0 256 * 257 * <p>Moves the cursor to the last row in the result set. 258 * 259 * @return true if the cursor is on a valid row; 260 * false if there are no rows in the result set 261 * @exception SQLException if a database access error occurs or the 262 * result set type is TYPE_FORWARD_ONLY. 263 */ 264 public boolean last() throws SQLException 265 { 266 NotImplemented(); 267 return false; 268 } 269 270 271 /*** 272 * JDBC 2.0 273 * 274 * <p>Retrieves the current row number. The first row is number 1, the 275 * second number 2, and so on. 276 * 277 * @return the current row number; 0 if there is no current row 278 * @exception SQLException if a database access error occurs 279 */ 280 public int getRow() throws SQLException 281 { 282 NotImplemented(); 283 return 0; 284 } 285 286 287 /*** 288 * JDBC 2.0 289 * 290 * <p>Moves the cursor to the given row number in the result set. 291 * 292 * <p>If the row number is positive, the cursor moves to 293 * the given row number with respect to the 294 * beginning of the result set. The first row is row 1, the second 295 * is row 2, and so on. 296 * 297 * <p>If the given row number is negative, the cursor moves to 298 * an absolute row position with respect to 299 * the end of the result set. For example, calling 300 * <code>absolute(-1)</code> positions the 301 * cursor on the last row, <code>absolute(-2)</code> indicates the next-to-last 302 * row, and so on. 303 * 304 * <p>An attempt to position the cursor beyond the first/last row in 305 * the result set leaves the cursor before/after the first/last 306 * row, respectively. 307 * 308 * <p>Note: Calling <code>absolute(1)</code> is the same 309 * as calling <code>first()</code>. 310 * Calling <code>absolute(-1)</code> is the same as calling <code>last()</code>. 311 * 312 * @return true if the cursor is on the result set; false otherwise 313 * @exception SQLException if a database access error occurs or 314 * row is 0, or result set type is TYPE_FORWARD_ONLY. 315 */ 316 public boolean absolute( int row ) throws SQLException 317 { 318 NotImplemented(); 319 return false; 320 } 321 322 323 /*** 324 * JDBC 2.0 325 * 326 * <p>Moves the cursor a relative number of rows, either positive or negative. 327 * Attempting to move beyond the first/last row in the 328 * result set positions the cursor before/after the 329 * the first/last row. Calling <code>relative(0)</code> is valid, but does 330 * not change the cursor position. 331 * 332 * <p>Note: Calling <code>relative(1)</code> 333 * is different from calling <code>next()</code> 334 * because is makes sense to call <code>next()</code> when there is no current row, 335 * for example, when the cursor is positioned before the first row 336 * or after the last row of the result set. 337 * 338 * @return true if the cursor is on a row; false otherwise 339 * @exception SQLException if a database access error occurs, there 340 * is no current row, or the result set type is TYPE_FORWARD_ONLY 341 */ 342 public boolean relative( int rows ) throws SQLException 343 { 344 NotImplemented(); 345 return false; 346 } 347 348 349 /*** 350 * JDBC 2.0 351 * 352 * <p>Moves the cursor to the previous row in the result set. 353 * 354 * <p>Note: <code>previous()</code> is not the same as 355 * <code>relative(-1)</code> because it 356 * makes sense to call</code>previous()</code> when there is no current row. 357 * 358 * @return true if the cursor is on a valid row; false if it is off the result set 359 * @exception SQLException if a database access error occurs or the 360 * result set type is TYPE_FORWARD_ONLY 361 */ 362 public boolean previous() throws SQLException 363 { 364 NotImplemented(); 365 return false; 366 } 367 368 369 //--------------------------------------------------------------------- 370 // Properties 371 //--------------------------------------------------------------------- 372 373 /*** 374 * JDBC 2.0 375 * 376 * The rows in a result set will be processed in a forward direction; 377 * first-to-last. 378 */ 379 int FETCH_FORWARD = 1000; 380 381 /*** 382 * JDBC 2.0 383 * 384 * The rows in a result set will be processed in a reverse direction; 385 * last-to-first. 386 */ 387 int FETCH_REVERSE = 1001; 388 389 /*** 390 * JDBC 2.0 391 * 392 * The order in which rows in a result set will be processed is unknown. 393 */ 394 int FETCH_UNKNOWN = 1002; 395 396 /*** 397 * JDBC 2.0 398 * 399 * Gives a hint as to the direction in which the rows in this result set 400 * will be processed. The initial value is determined by the statement 401 * that produced the result set. The fetch direction may be changed 402 * at any time. 403 * 404 * @exception SQLException if a database access error occurs or 405 * the result set type is TYPE_FORWARD_ONLY and the fetch direction is not 406 * FETCH_FORWARD. 407 */ 408 public void setFetchDirection(int direction) throws SQLException 409 { 410 NotImplemented(); 411 } 412 413 414 /*** 415 * JDBC 2.0 416 * 417 * Returns the fetch direction for this result set. 418 * 419 * @return the current fetch direction for this result set 420 * @exception SQLException if a database access error occurs 421 */ 422 public int getFetchDirection() throws SQLException 423 { 424 NotImplemented(); 425 return 0; 426 } 427 428 429 /*** 430 * JDBC 2.0 431 * 432 * Gives the JDBC driver a hint as to the number of rows that should 433 * be fetched from the database when more rows are needed for this result 434 * set. If the fetch size specified is zero, the JDBC driver 435 * ignores the value and is free to make its own best guess as to what 436 * the fetch size should be. The default value is set by the statement 437 * that created the result set. The fetch size may be changed at any 438 * time. 439 * 440 * @param rows the number of rows to fetch 441 * @exception SQLException if a database access error occurs or the 442 * condition 0 <= rows <= this.getMaxRows() is not satisfied. 443 */ 444 public void setFetchSize(int rows) throws SQLException 445 { 446 NotImplemented(); 447 } 448 449 450 /*** 451 * JDBC 2.0 452 * 453 * Returns the fetch size for this result set. 454 * 455 * @return the current fetch size for this result set 456 * @exception SQLException if a database access error occurs 457 */ 458 public int getFetchSize() throws SQLException 459 { 460 NotImplemented(); 461 return 0; 462 } 463 464 465 /*** 466 * JDBC 2.0 467 * The type for a <code>ResultSet</code> object whose cursor may 468 * move only forward. 469 */ 470 int TYPE_FORWARD_ONLY = 1003; 471 472 /*** 473 * JDBC 2.0 474 * The type for a <code>ResultSet</code> object that is scrollable 475 * but generally not sensitive to changes made by others. 476 * 477 */ 478 int TYPE_SCROLL_INSENSITIVE = 1004; 479 480 /*** 481 * JDBC 2.0 482 * The type for a <code>ResultSet</code> object that is scrollable 483 * and generally sensitive to changes made by others. 484 */ 485 int TYPE_SCROLL_SENSITIVE = 1005; 486 487 /*** 488 * JDBC 2.0 489 * 490 * Returns the type of this result set. The type is determined by 491 * the statement that created the result set. 492 * 493 * @return TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE, or 494 * TYPE_SCROLL_SENSITIVE 495 * @exception SQLException if a database access error occurs 496 */ 497 public int getType() throws SQLException 498 { 499 NotImplemented(); 500 return 0; 501 } 502 503 504 /*** 505 * JDBC 2.0 506 * The concurrency mode for a <code>ResultSet</code> object 507 * that may NOT be updated. 508 * 509 */ 510 int CONCUR_READ_ONLY = 1007; 511 512 /*** 513 * JDBC 2.0 514 * The concurrency mode for a <code>ResultSet</code> object 515 * that may be updated. 516 * 517 */ 518 int CONCUR_UPDATABLE = 1008; 519 520 /*** 521 * JDBC 2.0 522 * 523 * Returns the concurrency mode of this result set. The concurrency 524 * used is determined by the statement that created the result set. 525 * 526 * @return the concurrency type, CONCUR_READ_ONLY or CONCUR_UPDATABLE 527 * @exception SQLException if a database access error occurs 528 */ 529 public int getConcurrency() throws SQLException 530 { 531 NotImplemented(); 532 return 0; 533 } 534 535 536 //--------------------------------------------------------------------- 537 // Updates 538 //--------------------------------------------------------------------- 539 540 /*** 541 * JDBC 2.0 542 * 543 * Indicates whether the current row has been updated. The value returned 544 * depends on whether or not the result set can detect updates. 545 * 546 * @return true if the row has been visibly updated by the owner or 547 * another, and updates are detected 548 * @exception SQLException if a database access error occurs 549 * 550 * @see DatabaseMetaData#updatesAreDetected 551 */ 552 public boolean rowUpdated() throws SQLException 553 { 554 NotImplemented(); 555 return false; 556 } 557 558 559 /*** 560 * JDBC 2.0 561 * 562 * Indicates whether the current row has had an insertion. The value returned 563 * depends on whether or not the result set can detect visible inserts. 564 * 565 * @return true if a row has had an insertion and insertions are detected 566 * @exception SQLException if a database access error occurs 567 * 568 * @see DatabaseMetaData#insertsAreDetected 569 */ 570 public boolean rowInserted() throws SQLException 571 { 572 NotImplemented(); 573 return false; 574 } 575 576 577 /*** 578 * JDBC 2.0 579 * 580 * Indicates whether a row has been deleted. A deleted row may leave 581 * a visible "hole" in a result set. This method can be used to 582 * detect holes in a result set. The value returned depends on whether 583 * or not the result set can detect deletions. 584 * 585 * @return true if a row was deleted and deletions are detected 586 * @exception SQLException if a database access error occurs 587 * 588 * @see DatabaseMetaData#deletesAreDetected 589 */ 590 public boolean rowDeleted() throws SQLException 591 { 592 NotImplemented(); 593 return false; 594 } 595 596 597 /*** 598 * JDBC 2.0 599 * 600 * Give a nullable column a null value. 601 * 602 * The <code>updateXXX</code> methods are used to update column values in the 603 * current row, or the insert row. The <code>updateXXX</code> methods do not 604 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 605 * methods are called to update the database. 606 * 607 * @param columnIndex the first column is 1, the second is 2, ... 608 * @exception SQLException if a database access error occurs 609 */ 610 public void updateNull(int columnIndex) throws SQLException 611 { 612 NotImplemented(); 613 } 614 615 616 /*** 617 * JDBC 2.0 618 * 619 * Updates a column with a boolean value. 620 * 621 * The <code>updateXXX</code> methods are used to update column values in the 622 * current row, or the insert row. The <code>updateXXX</code> methods do not 623 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 624 * methods are called to update the database. 625 * 626 * @param columnIndex the first column is 1, the second is 2, ... 627 * @param x the new column value 628 * @exception SQLException if a database access error occurs 629 */ 630 public void updateBoolean(int columnIndex, boolean x) throws SQLException 631 { 632 NotImplemented(); 633 } 634 635 636 /*** 637 * JDBC 2.0 638 * 639 * Updates a column with a byte value. 640 * 641 * The <code>updateXXX</code> methods are used to update column values in the 642 * current row, or the insert row. The <code>updateXXX</code> methods do not 643 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 644 * methods are called to update the database. 645 * 646 * @param columnIndex the first column is 1, the second is 2, ... 647 * @param x the new column value 648 * @exception SQLException if a database access error occurs 649 */ 650 public void updateByte(int columnIndex, byte x) throws SQLException 651 { 652 NotImplemented(); 653 } 654 655 656 /*** 657 * JDBC 2.0 658 * 659 * Updates a column with a short value. 660 * 661 * The <code>updateXXX</code> methods are used to update column values in the 662 * current row, or the insert row. The <code>updateXXX</code> methods do not 663 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 664 * methods are called to update the database. 665 * 666 * @param columnIndex the first column is 1, the second is 2, ... 667 * @param x the new column value 668 * @exception SQLException if a database access error occurs 669 */ 670 public void updateShort(int columnIndex, short x) throws SQLException 671 { 672 NotImplemented(); 673 } 674 675 676 /*** 677 * JDBC 2.0 678 * 679 * Updates a column with an integer value. 680 * 681 * The <code>updateXXX</code> methods are used to update column values in the 682 * current row, or the insert row. The <code>updateXXX</code> methods do not 683 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 684 * methods are called to update the database. 685 * 686 * @param columnIndex the first column is 1, the second is 2, ... 687 * @param x the new column value 688 * @exception SQLException if a database access error occurs 689 */ 690 public void updateInt(int columnIndex, int x) throws SQLException 691 { 692 NotImplemented(); 693 } 694 695 696 /*** 697 * JDBC 2.0 698 * 699 * Updates a column with a long value. 700 * 701 * The <code>updateXXX</code> methods are used to update column values in the 702 * current row, or the insert row. The <code>updateXXX</code> methods do not 703 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 704 * methods are called to update the database. 705 * 706 * @param columnIndex the first column is 1, the second is 2, ... 707 * @param x the new column value 708 * @exception SQLException if a database access error occurs 709 */ 710 public void updateLong(int columnIndex, long x) throws SQLException 711 { 712 NotImplemented(); 713 } 714 715 716 /*** 717 * JDBC 2.0 718 * 719 * Updates a column with a float value. 720 * 721 * The <code>updateXXX</code> methods are used to update column values in the 722 * current row, or the insert row. The <code>updateXXX</code> methods do not 723 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 724 * methods are called to update the database. 725 * 726 * @param columnIndex the first column is 1, the second is 2, ... 727 * @param x the new column value 728 * @exception SQLException if a database access error occurs 729 */ 730 public void updateFloat(int columnIndex, float x) throws SQLException 731 { 732 NotImplemented(); 733 } 734 735 736 /*** 737 * JDBC 2.0 738 * 739 * Updates a column with a Double value. 740 * 741 * The <code>updateXXX</code> methods are used to update column values in the 742 * current row, or the insert row. The <code>updateXXX</code> methods do not 743 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 744 * methods are called to update the database. 745 * 746 * @param columnIndex the first column is 1, the second is 2, ... 747 * @param x the new column value 748 * @exception SQLException if a database access error occurs 749 */ 750 public void updateDouble(int columnIndex, double x) throws SQLException 751 { 752 NotImplemented(); 753 } 754 755 756 /*** 757 * JDBC 2.0 758 * 759 * Updates a column with a BigDecimal value. 760 * 761 * The <code>updateXXX</code> methods are used to update column values in the 762 * current row, or the insert row. The <code>updateXXX</code> methods do not 763 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 764 * methods are called to update the database. 765 * 766 * @param columnIndex the first column is 1, the second is 2, ... 767 * @param x the new column value 768 * @exception SQLException if a database access error occurs 769 */ 770 public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException 771 { 772 NotImplemented(); 773 } 774 775 776 /*** 777 * JDBC 2.0 778 * 779 * Updates a column with a String value. 780 * 781 * The <code>updateXXX</code> methods are used to update column values in the 782 * current row, or the insert row. The <code>updateXXX</code> methods do not 783 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 784 * methods are called to update the database. 785 * 786 * @param columnIndex the first column is 1, the second is 2, ... 787 * @param x the new column value 788 * @exception SQLException if a database access error occurs 789 */ 790 public void updateString(int columnIndex, String x) throws SQLException 791 { 792 NotImplemented(); 793 } 794 795 796 /*** 797 * JDBC 2.0 798 * 799 * Updates a column with a byte array value. 800 * 801 * The <code>updateXXX</code> methods are used to update column values in the 802 * current row, or the insert row. The <code>updateXXX</code> methods do not 803 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 804 * methods are called to update the database. 805 * 806 * @param columnIndex the first column is 1, the second is 2, ... 807 * @param x the new column value 808 * @exception SQLException if a database access error occurs 809 */ 810 public void updateBytes(int columnIndex, byte x[]) throws SQLException 811 { 812 NotImplemented(); 813 } 814 815 816 /*** 817 * JDBC 2.0 818 * 819 * Updates a column with a Date value. 820 * 821 * The <code>updateXXX</code> methods are used to update column values in the 822 * current row, or the insert row. The <code>updateXXX</code> methods do not 823 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 824 * methods are called to update the database. 825 * 826 * @param columnIndex the first column is 1, the second is 2, ... 827 * @param x the new column value 828 * @exception SQLException if a database access error occurs 829 */ 830 public void updateDate(int columnIndex, java.sql.Date x) throws SQLException 831 { 832 NotImplemented(); 833 } 834 835 836 /*** 837 * JDBC 2.0 838 * 839 * Updates a column with a Time value. 840 * 841 * The <code>updateXXX</code> methods are used to update column values in the 842 * current row, or the insert row. The <code>updateXXX</code> methods do not 843 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 844 * methods are called to update the database. 845 * 846 * @param columnIndex the first column is 1, the second is 2, ... 847 * @param x the new column value 848 * @exception SQLException if a database access error occurs 849 */ 850 public void updateTime(int columnIndex, java.sql.Time x) throws SQLException 851 { 852 NotImplemented(); 853 } 854 855 /*** 856 * JDBC 2.0 857 * 858 * Updates a column with a Timestamp value. 859 * 860 * The <code>updateXXX</code> methods are used to update column values in the 861 * current row, or the insert row. The <code>updateXXX</code> methods do not 862 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 863 * methods are called to update the database. 864 * 865 * @param columnIndex the first column is 1, the second is 2, ... 866 * @param x the new column value 867 * @exception SQLException if a database access error occurs 868 */ 869 public void updateTimestamp(int columnIndex, java.sql.Timestamp x) throws SQLException 870 { 871 NotImplemented(); 872 } 873 874 875 /*** 876 * JDBC 2.0 877 * 878 * Updates a column with an ascii stream value. 879 * 880 * The <code>updateXXX</code> methods are used to update column values in the 881 * current row, or the insert row. The <code>updateXXX</code> methods do not 882 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 883 * methods are called to update the database. 884 * 885 * @param columnIndex the first column is 1, the second is 2, ... 886 * @param x the new column value 887 * @param length the length of the stream 888 * @exception SQLException if a database access error occurs 889 */ 890 public void updateAsciiStream(int columnIndex, 891 java.io.InputStream x, 892 int length) throws SQLException 893 { 894 NotImplemented(); 895 } 896 897 898 /*** 899 * JDBC 2.0 900 * 901 * Updates a column with a binary stream value. 902 * 903 * The <code>updateXXX</code> methods are used to update column values in the 904 * current row, or the insert row. The <code>updateXXX</code> methods do not 905 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 906 * methods are called to update the database. 907 * 908 * @param columnIndex the first column is 1, the second is 2, ... 909 * @param x the new column value 910 * @param length the length of the stream 911 * @exception SQLException if a database access error occurs 912 */ 913 public void updateBinaryStream(int columnIndex, 914 java.io.InputStream x, 915 int length) throws SQLException 916 { 917 NotImplemented(); 918 } 919 920 921 /*** 922 * JDBC 2.0 923 * 924 * Updates a column with a character stream value. 925 * 926 * The <code>updateXXX</code> methods are used to update column values in the 927 * current row, or the insert row. The <code>updateXXX</code> methods do not 928 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 929 * methods are called to update the database. 930 * 931 * @param columnIndex the first column is 1, the second is 2, ... 932 * @param x the new column value 933 * @param length the length of the stream 934 * @exception SQLException if a database access error occurs 935 */ 936 public void updateCharacterStream(int columnIndex, 937 java.io.Reader x, 938 int length) throws SQLException 939 { 940 NotImplemented(); 941 } 942 943 /*** 944 * JDBC 2.0 945 * 946 * Updates a column with an Object value. 947 * 948 * The <code>updateXXX</code> methods are used to update column values in the 949 * current row, or the insert row. The <code>updateXXX</code> methods do not 950 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 951 * methods are called to update the database. 952 * 953 * @param columnIndex the first column is 1, the second is 2, ... 954 * @param x the new column value 955 * @param scale For java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types 956 * this is the number of digits after the decimal. For all other 957 * types this value will be ignored. 958 * @exception SQLException if a database access error occurs 959 */ 960 public void updateObject(int columnIndex, Object x, int scale) throws SQLException 961 { 962 NotImplemented(); 963 } 964 965 966 /*** 967 * JDBC 2.0 968 * 969 * Updates a column with an Object value. 970 * 971 * The <code>updateXXX</code> methods are used to update column values in the 972 * current row, or the insert row. The <code>updateXXX</code> methods do not 973 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 974 * methods are called to update the database. 975 * 976 * @param columnIndex the first column is 1, the second is 2, ... 977 * @param x the new column value 978 * @exception SQLException if a database access error occurs 979 */ 980 public void updateObject(int columnIndex, Object x) throws SQLException 981 { 982 NotImplemented(); 983 } 984 985 986 /*** 987 * JDBC 2.0 988 * 989 * Updates a column with a null value. 990 * 991 * The <code>updateXXX</code> methods are used to update column values in the 992 * current row, or the insert row. The <code>updateXXX</code> methods do not 993 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 994 * methods are called to update the database. 995 * 996 * @param columnName the name of the column 997 * @exception SQLException if a database access error occurs 998 */ 999 public void updateNull(String columnName) throws SQLException 1000 { 1001 NotImplemented(); 1002 } 1003 1004 1005 /*** 1006 * JDBC 2.0 1007 * 1008 * Updates a column with a boolean value. 1009 * 1010 * The <code>updateXXX</code> methods are used to update column values in the 1011 * current row, or the insert row. The <code>updateXXX</code> methods do not 1012 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 1013 * methods are called to update the database. 1014 * 1015 * @param columnName the name of the column 1016 * @param x the new column value 1017 * @exception SQLException if a database access error occurs 1018 */ 1019 public void updateBoolean(String columnName, boolean x) throws SQLException 1020 { 1021 NotImplemented(); 1022 } 1023 1024 1025 /*** 1026 * JDBC 2.0 1027 * 1028 * Updates a column with a byte value. 1029 * 1030 * The <code>updateXXX</code> methods are used to update column values in the 1031 * current row, or the insert row. The <code>updateXXX</code> methods do not 1032 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 1033 * methods are called to update the database. 1034 * 1035 * @param columnName the name of the column 1036 * @param x the new column value 1037 * @exception SQLException if a database access error occurs 1038 */ 1039 public void updateByte(String columnName, byte x) throws SQLException 1040 { 1041 NotImplemented(); 1042 } 1043 1044 1045 /*** 1046 * JDBC 2.0 1047 * 1048 * Updates a column with a short value. 1049 * 1050 * The <code>updateXXX</code> methods are used to update column values in the 1051 * current row, or the insert row. The <code>updateXXX</code> methods do not 1052 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 1053 * methods are called to update the database. 1054 * 1055 * @param columnName the name of the column 1056 * @param x the new column value 1057 * @exception SQLException if a database access error occurs 1058 */ 1059 public void updateShort(String columnName, short x) throws SQLException 1060 { 1061 NotImplemented(); 1062 } 1063 1064 1065 /*** 1066 * JDBC 2.0 1067 * 1068 * Updates a column with an integer value. 1069 * 1070 * The <code>updateXXX</code> methods are used to update column values in the 1071 * current row, or the insert row. The <code>updateXXX</code> methods do not 1072 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 1073 * methods are called to update the database. 1074 * 1075 * @param columnName the name of the column 1076 * @param x the new column value 1077 * @exception SQLException if a database access error occurs 1078 */ 1079 public void updateInt(String columnName, int x) throws SQLException 1080 { 1081 NotImplemented(); 1082 } 1083 1084 1085 /*** 1086 * JDBC 2.0 1087 * 1088 * Updates a column with a long value. 1089 * 1090 * The <code>updateXXX</code> methods are used to update column values in the 1091 * current row, or the insert row. The <code>updateXXX</code> methods do not 1092 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 1093 * methods are called to update the database. 1094 * 1095 * @param columnName the name of the column 1096 * @param x the new column value 1097 * @exception SQLException if a database access error occurs 1098 */ 1099 public void updateLong(String columnName, long x) throws SQLException 1100 { 1101 NotImplemented(); 1102 } 1103 1104 1105 /*** 1106 * JDBC 2.0 1107 * 1108 * Updates a column with a float value. 1109 * 1110 * The <code>updateXXX</code> methods are used to update column values in the 1111 * current row, or the insert row. The <code>updateXXX</code> methods do not 1112 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 1113 * methods are called to update the database. 1114 * 1115 * @param columnName the name of the column 1116 * @param x the new column value 1117 * @exception SQLException if a database access error occurs 1118 */ 1119 public void updateFloat(String columnName, float x) throws SQLException 1120 { 1121 NotImplemented(); 1122 } 1123 1124 1125 /*** 1126 * JDBC 2.0 1127 * 1128 * Updates a column with a double value. 1129 * 1130 * The <code>updateXXX</code> methods are used to update column values in the 1131 * current row, or the insert row. The <code>updateXXX</code> methods do not 1132 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 1133 * methods are called to update the database. 1134 * 1135 * @param columnName the name of the column 1136 * @param x the new column value 1137 * @exception SQLException if a database access error occurs 1138 */ 1139 public void updateDouble(String columnName, double x) throws SQLException 1140 { 1141 NotImplemented(); 1142 } 1143 1144 1145 /*** 1146 * JDBC 2.0 1147 * 1148 * Updates a column with a BigDecimal value. 1149 * 1150 * The <code>updateXXX</code> methods are used to update column values in the 1151 * current row, or the insert row. The <code>updateXXX</code> methods do not 1152 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 1153 * methods are called to update the database. 1154 * 1155 * @param columnName the name of the column 1156 * @param x the new column value 1157 * @exception SQLException if a database access error occurs 1158 */ 1159 public void updateBigDecimal(String columnName, BigDecimal x) throws SQLException 1160 { 1161 NotImplemented(); 1162 } 1163 1164 1165 /*** 1166 * JDBC 2.0 1167 * 1168 * Updates a column with a String value. 1169 * 1170 * The <code>updateXXX</code> methods are used to update column values in the 1171 * current row, or the insert row. The <code>updateXXX</code> methods do not 1172 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 1173 * methods are called to update the database. 1174 * 1175 * @param columnName the name of the column 1176 * @param x the new column value 1177 * @exception SQLException if a database access error occurs 1178 */ 1179 public void updateString(String columnName, String x) throws SQLException 1180 { 1181 NotImplemented(); 1182 } 1183 1184 1185 /*** 1186 * JDBC 2.0 1187 * 1188 * Updates a column with a byte array value. 1189 * 1190 * The <code>updateXXX</code> methods are used to update column values in the 1191 * current row, or the insert row. The <code>updateXXX</code> methods do not 1192 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 1193 * methods are called to update the database. 1194 * 1195 * @param columnName the name of the column 1196 * @param x the new column value 1197 * @exception SQLException if a database access error occurs 1198 */ 1199 public void updateBytes(String columnName, byte x[]) throws SQLException 1200 { 1201 NotImplemented(); 1202 } 1203 1204 1205 /*** 1206 * JDBC 2.0 1207 * 1208 * Updates a column with a Date value. 1209 * 1210 * The <code>updateXXX</code> methods are used to update column values in the 1211 * current row, or the insert row. The <code>updateXXX</code> methods do not 1212 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 1213 * methods are called to update the database. 1214 * 1215 * @param columnName the name of the column 1216 * @param x the new column value 1217 * @exception SQLException if a database access error occurs 1218 */ 1219 public void updateDate(String columnName, java.sql.Date x) throws SQLException 1220 { 1221 NotImplemented(); 1222 } 1223 1224 1225 /*** 1226 * JDBC 2.0 1227 * 1228 * Updates a column with a Time value. 1229 * 1230 * The <code>updateXXX</code> methods are used to update column values in the 1231 * current row, or the insert row. The <code>updateXXX</code> methods do not 1232 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 1233 * methods are called to update the database. 1234 * 1235 * @param columnName the name of the column 1236 * @param x the new column value 1237 * @exception SQLException if a database access error occurs 1238 */ 1239 public void updateTime(String columnName, java.sql.Time x) throws SQLException 1240 { 1241 NotImplemented(); 1242 } 1243 1244 1245 /*** 1246 * JDBC 2.0 1247 * 1248 * Updates a column with a Timestamp value. 1249 * 1250 * The <code>updateXXX</code> methods are used to update column values in the 1251 * current row, or the insert row. The <code>updateXXX</code> methods do not 1252 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 1253 * methods are called to update the database. 1254 * 1255 * @param columnName the name of the column 1256 * @param x the new column value 1257 * @exception SQLException if a database access error occurs 1258 */ 1259 public void updateTimestamp(String columnName, java.sql.Timestamp x) throws SQLException 1260 { 1261 NotImplemented(); 1262 } 1263 1264 1265 /*** 1266 * JDBC 2.0 1267 * 1268 * Updates a column with an ascii stream value. 1269 * 1270 * The <code>updateXXX</code> methods are used to update column values in the 1271 * current row, or the insert row. The <code>updateXXX</code> methods do not 1272 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 1273 * methods are called to update the database. 1274 * 1275 * @param columnName the name of the column 1276 * @param x the new column value 1277 * @param length of the stream 1278 * @exception SQLException if a database access error occurs 1279 */ 1280 public void updateAsciiStream(String columnName, 1281 java.io.InputStream x, 1282 int length) throws SQLException 1283 { 1284 NotImplemented(); 1285 } 1286 1287 1288 /*** 1289 * JDBC 2.0 1290 * 1291 * Updates a column with a binary stream value. 1292 * 1293 * The <code>updateXXX</code> methods are used to update column values in the 1294 * current row, or the insert row. The <code>updateXXX</code> methods do not 1295 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 1296 * methods are called to update the database. 1297 * 1298 * @param columnName the name of the column 1299 * @param x the new column value 1300 * @param length of the stream 1301 * @exception SQLException if a database access error occurs 1302 */ 1303 public void updateBinaryStream(String columnName, 1304 java.io.InputStream x, 1305 int length) throws SQLException 1306 { 1307 NotImplemented(); 1308 } 1309 1310 1311 /*** 1312 * JDBC 2.0 1313 * 1314 * Updates a column with a character stream value. 1315 * 1316 * The <code>updateXXX</code> methods are used to update column values in the 1317 * current row, or the insert row. The <code>updateXXX</code> methods do not 1318 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 1319 * methods are called to update the database. 1320 * 1321 * @param columnName the name of the column 1322 * @param x the new column value 1323 * @param length of the stream 1324 * @exception SQLException if a database access error occurs 1325 */ 1326 public void updateCharacterStream(String columnName, 1327 java.io.Reader reader, 1328 int length) throws SQLException 1329 { 1330 NotImplemented(); 1331 } 1332 1333 1334 /*** 1335 * JDBC 2.0 1336 * 1337 * Updates a column with an Object value. 1338 * 1339 * The <code>updateXXX</code> methods are used to update column values in the 1340 * current row, or the insert row. The <code>updateXXX</code> methods do not 1341 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 1342 * methods are called to update the database. 1343 * 1344 * @param columnName the name of the column 1345 * @param x the new column value 1346 * @param scale For java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types 1347 * this is the number of digits after the decimal. For all other 1348 * types this value will be ignored. 1349 * @exception SQLException if a database access error occurs 1350 */ 1351 public void updateObject(String columnName, Object x, int scale) throws SQLException 1352 { 1353 NotImplemented(); 1354 } 1355 1356 1357 /*** 1358 * JDBC 2.0 1359 * 1360 * Updates a column with an Object value. 1361 * 1362 * The <code>updateXXX</code> methods are used to update column values in the 1363 * current row, or the insert row. The <code>updateXXX</code> methods do not 1364 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 1365 * methods are called to update the database. 1366 * 1367 * @param columnName the name of the column 1368 * @param x the new column value 1369 * @exception SQLException if a database access error occurs 1370 */ 1371 public void updateObject(String columnName, Object x) throws SQLException 1372 { 1373 NotImplemented(); 1374 } 1375 1376 1377 /*** 1378 * JDBC 2.0 1379 * 1380 * Inserts the contents of the insert row into the result set and 1381 * the database. Must be on the insert row when this method is called. 1382 * 1383 * @exception SQLException if a database access error occurs, 1384 * if called when not on the insert row, or if not all of non-nullable columns in 1385 * the insert row have been given a value 1386 */ 1387 public void insertRow() throws SQLException 1388 { 1389 NotImplemented(); 1390 } 1391 1392 1393 /*** 1394 * JDBC 2.0 1395 * 1396 * Updates the underlying database with the new contents of the 1397 * current row. Cannot be called when on the insert row. 1398 * 1399 * @exception SQLException if a database access error occurs or 1400 * if called when on the insert row 1401 */ 1402 public void updateRow() throws SQLException 1403 { 1404 NotImplemented(); 1405 } 1406 1407 1408 /*** 1409 * JDBC 2.0 1410 * 1411 * Deletes the current row from the result set and the underlying 1412 * database. Cannot be called when on the insert row. 1413 * 1414 * @exception SQLException if a database access error occurs or if 1415 * called when on the insert row. 1416 */ 1417 public void deleteRow() throws SQLException 1418 { 1419 NotImplemented(); 1420 } 1421 1422 1423 /*** 1424 * JDBC 2.0 1425 * 1426 * Refreshes the current row with its most recent value in 1427 * the database. Cannot be called when on the insert row. 1428 * 1429 * The <code>refreshRow</code> method provides a way for an application to 1430 * explicitly tell the JDBC driver to refetch a row(s) from the 1431 * database. An application may want to call <code>refreshRow</code> when 1432 * caching or prefetching is being done by the JDBC driver to 1433 * fetch the latest value of a row from the database. The JDBC driver 1434 * may actually refresh multiple rows at once if the fetch size is 1435 * greater than one. 1436 * 1437 * All values are refetched subject to the transaction isolation 1438 * level and cursor sensitivity. If <code>refreshRow</code> is called after 1439 * calling <code>updateXXX</code>, but before calling <code>updateRow</code>, then the 1440 * updates made to the row are lost. Calling the method <code>refreshRow</code> frequently 1441 * will likely slow performance. 1442 * 1443 * @exception SQLException if a database access error occurs or if 1444 * called when on the insert row 1445 */ 1446 public void refreshRow() throws SQLException 1447 { 1448 NotImplemented(); 1449 } 1450 1451 1452 /*** 1453 * JDBC 2.0 1454 * 1455 * Cancels the updates made to a row. 1456 * This method may be called after calling an 1457 * <code>updateXXX</code> method(s) and before calling <code>updateRow</code> to rollback 1458 * the updates made to a row. If no updates have been made or 1459 * <code>updateRow</code> has already been called, then this method has no 1460 * effect. 1461 * 1462 * @exception SQLException if a database access error occurs or if 1463 * called when on the insert row 1464 * 1465 */ 1466 public void cancelRowUpdates() throws SQLException 1467 { 1468 NotImplemented(); 1469 } 1470 1471 1472 /*** 1473 * JDBC 2.0 1474 * 1475 * Moves the cursor to the insert row. The current cursor position is 1476 * remembered while the cursor is positioned on the insert row. 1477 * 1478 * The insert row is a special row associated with an updatable 1479 * result set. It is essentially a buffer where a new row may 1480 * be constructed by calling the <code>updateXXX</code> methods prior to 1481 * inserting the row into the result set. 1482 * 1483 * Only the <code>updateXXX</code>, <code>getXXX</code>, 1484 * and <code>insertRow</code> methods may be 1485 * called when the cursor is on the insert row. All of the columns in 1486 * a result set must be given a value each time this method is 1487 * called before calling <code>insertRow</code>. 1488 * The method <code>updateXXX</code> must be called before a 1489 * <code>getXXX</code> method can be called on a column value. 1490 * 1491 * @exception SQLException if a database access error occurs 1492 * or the result set is not updatable 1493 */ 1494 public void moveToInsertRow() throws SQLException 1495 { 1496 NotImplemented(); 1497 } 1498 1499 1500 /*** 1501 * JDBC 2.0 1502 * 1503 * Moves the cursor to the remembered cursor position, usually the 1504 * current row. This method has no effect if the cursor is not on the insert 1505 * row. 1506 * 1507 * @exception SQLException if a database access error occurs 1508 * or the result set is not updatable 1509 */ 1510 public void moveToCurrentRow() throws SQLException 1511 { 1512 NotImplemented(); 1513 } 1514 1515 1516 /*** 1517 * JDBC 2.0 1518 * 1519 * Returns the Statement that produced this <code>ResultSet</code> object. 1520 * If the result set was generated some other way, such as by a 1521 * <code>DatabaseMetaData</code> method, this method returns <code>null</code>. 1522 * 1523 * @return the Statment that produced the result set or 1524 * null if the result set was produced some other way 1525 * @exception SQLException if a database access error occurs 1526 */ 1527 public java.sql.Statement getStatement() throws SQLException 1528 { 1529 return stmt; 1530 } 1531 1532 1533 /*** 1534 * JDBC 2.0 1535 * 1536 * Returns the value of a column in the current row as a Java object. 1537 * This method uses the given <code>Map</code> object 1538 * for the custom mapping of the 1539 * SQL structured or distinct type that is being retrieved. 1540 * 1541 * @param i the first column is 1, the second is 2, ... 1542 * @param map the mapping from SQL type names to Java classes 1543 * @return an object representing the SQL value 1544 */ 1545 public Object getObject(int i, java.util.Map map) throws SQLException 1546 { 1547 NotImplemented(); 1548 return null; 1549 } 1550 1551 1552 /*** 1553 * JDBC 2.0 1554 * 1555 * Gets a REF(<structured-type>) column value from the current row. 1556 * 1557 * @param i the first column is 1, the second is 2, ... 1558 * @return a <code>Ref</code> object representing an SQL REF value 1559 */ 1560 public Ref getRef(int i) throws SQLException 1561 { 1562 NotImplemented(); 1563 return null; 1564 } 1565 1566 1567 /*** 1568 * JDBC 2.0 1569 * 1570 * Gets a BLOB value in the current row of this <code>ResultSet</code> object. 1571 * 1572 * @param i the first column is 1, the second is 2, ... 1573 * @return a <code>Blob</code> object representing the SQL BLOB value in 1574 * the specified column 1575 */ 1576 public Blob getBlob(int i) throws SQLException 1577 { 1578 NotImplemented(); 1579 return null; 1580 } 1581 1582 1583 /*** 1584 * JDBC 2.0 1585 * 1586 * Gets a CLOB value in the current row of this <code>ResultSet</code> object. 1587 * 1588 * @param i the first column is 1, the second is 2, ... 1589 * @return a <code>Clob</code> object representing the SQL CLOB value in 1590 * the specified column 1591 */ 1592 public Clob getClob(int i) throws SQLException 1593 { 1594 NotImplemented(); 1595 return null; 1596 } 1597 1598 1599 /*** 1600 * JDBC 2.0 1601 * 1602 * Gets an SQL ARRAY value from the current row of this <code>ResultSet</code> object. 1603 * 1604 * @param i the first column is 1, the second is 2, ... 1605 * @return an <code>Array</code> object representing the SQL ARRAY value in 1606 * the specified column 1607 */ 1608 public Array getArray(int i) throws SQLException 1609 { 1610 NotImplemented(); 1611 return null; 1612 } 1613 1614 1615 /*** 1616 * JDBC 2.0 1617 * 1618 * Returns the value in the specified column as a Java object. 1619 * This method uses the specified <code>Map</code> object for 1620 * custom mapping if appropriate. 1621 * 1622 * @param colName the name of the column from which to retrieve the value 1623 * @param map the mapping from SQL type names to Java classes 1624 * @return an object representing the SQL value in the specified column 1625 */ 1626 public Object getObject(String colName, java.util.Map map) throws SQLException 1627 { 1628 NotImplemented(); 1629 return null; 1630 } 1631 1632 1633 /*** 1634 * JDBC 2.0 1635 * 1636 * Gets a REF(<structured-type>) column value from the current row. 1637 * 1638 * @param colName the column name 1639 * @return a <code>Ref</code> object representing the SQL REF value in 1640 * the specified column 1641 */ 1642 public Ref getRef(String colName) throws SQLException 1643 { 1644 NotImplemented(); 1645 return null; 1646 } 1647 1648 1649 /*** 1650 * JDBC 2.0 1651 * 1652 * Gets a BLOB value in the current row of this <code>ResultSet</code> object. 1653 * 1654 * @param colName the name of the column from which to retrieve the value 1655 * @return a <code>Blob</code> object representing the SQL BLOB value in 1656 * the specified column 1657 */ 1658 public Blob getBlob(String colName) throws SQLException 1659 { 1660 NotImplemented(); 1661 return null; 1662 } 1663 1664 1665 /*** 1666 * JDBC 2.0 1667 * 1668 * Gets a CLOB value in the current row of this <code>ResultSet</code> object. 1669 * 1670 * @param colName the name of the column from which to retrieve the value 1671 * @return a <code>Clob</code> object representing the SQL CLOB value in 1672 * the specified column 1673 */ 1674 public Clob getClob(String colName) throws SQLException 1675 { 1676 NotImplemented(); 1677 return null; 1678 } 1679 1680 1681 /*** 1682 * JDBC 2.0 1683 * 1684 * Gets an SQL ARRAY value in the current row of this <code>ResultSet</code> object. 1685 * 1686 * @param colName the name of the column from which to retrieve the value 1687 * @return an <code>Array</code> object representing the SQL ARRAY value in 1688 * the specified column 1689 */ 1690 public Array getArray(String colName) throws SQLException 1691 { 1692 NotImplemented(); 1693 return null; 1694 } 1695 1696 1697 1698 /*** 1699 * Gets the value of a column in the current row as a java.sql.Timestamp 1700 * object. This method uses the given calendar to construct an 1701 * appropriate millisecond value for the Timestamp if the underlying 1702 * database does not store timezone information. 1703 * 1704 * @param columnIndex the first column is 1, the second is 2, ... 1705 * @param cal the calendar to use in constructing the timestamp 1706 * @return the column value; if the value is SQL NULL, the result is null 1707 * @exception SQLException if a database access error occurs 1708 */ 1709 public java.sql.Timestamp getTimestamp(int columnIndex, Calendar cal) 1710 throws SQLException 1711 { 1712 NotImplemented(); 1713 return null; 1714 } 1715 1716 1717 /*** 1718 * Gets the value of a column in the current row as a 1719 * java.sql.Timestamp object. This method uses the given calendar 1720 * to construct an appropriate millisecond value for the Timestamp 1721 * if the underlying database does not store timezone information. 1722 * 1723 * @param columnName the SQL name of the column 1724 * @param cal the calendar to use in constructing the timestamp 1725 * @return the column value; if the value is SQL NULL, the result is null 1726 * @exception SQLException if a database access error occurs 1727 */ 1728 public java.sql.Timestamp getTimestamp(String columnName, Calendar cal) 1729 throws SQLException 1730 { 1731 NotImplemented(); 1732 return null; 1733 } 1734 1735 1736 1737 /*** 1738 * JDBC 2.0 1739 * 1740 * Gets the value of a column in the current row as a 1741 * java.sql.Date object. This method uses the given calendar to 1742 * construct an appropriate millisecond value for the Date if the 1743 * underlying database does not store timezone information. 1744 * 1745 * @param columnIndex the first column is 1, the second is 2, ... 1746 * @param cal the calendar to use in constructing the date 1747 * @return the column value; if the value is SQL NULL, the result is null 1748 * @exception SQLException if a database access error occurs 1749 */ 1750 public java.sql.Date getDate(int columnIndex, Calendar cal) throws SQLException 1751 { 1752 NotImplemented(); 1753 return null; 1754 } 1755 1756 1757 /*** 1758 * Gets the value of a column in the current row as a 1759 * java.sql.Date object. This method uses the given calendar to 1760 * construct an appropriate millisecond value for the Date, if the 1761 * underlying database does not store timezone information. 1762 * 1763 * @param columnName the SQL name of the column from which to retrieve the value 1764 * @param cal the calendar to use in constructing the date 1765 * @return the column value; if the value is SQL NULL, the result is null 1766 * @exception SQLException if a database access error occurs 1767 */ 1768 public java.sql.Date getDate(String columnName, Calendar cal) throws SQLException 1769 { 1770 NotImplemented(); 1771 return null; 1772 } 1773 1774 1775 /*** 1776 * Gets the value of a column in the current row as a 1777 * java.sql.Time object. This method uses the given calendar to 1778 * construct an appropriate millisecond value for the Time if the 1779 * underlying database does not store timezone information. 1780 * 1781 * @param columnIndex the first column is 1, the second is 2, ... 1782 * @param cal the calendar to use in constructing the time 1783 * @return the column value; if the value is SQL NULL, the result is null 1784 * @exception SQLException if a database access error occurs 1785 */ 1786 public java.sql.Time getTime(int columnIndex, Calendar cal) 1787 throws SQLException 1788 { 1789 NotImplemented(); 1790 return null; 1791 } 1792 1793 1794 /*** 1795 * Gets the value of a column in the current row as a java.sql.Time 1796 * object. This method uses the given calendar to construct an 1797 * appropriate millisecond 1798 * value for the Time if the underlying database does not store 1799 * timezone information. 1800 * 1801 * @param columnName the SQL name of the column 1802 * @param cal the calendar to use in constructing the time 1803 * @return the column value; if the value is SQL NULL, the result is null 1804 * @exception SQLException if a database access error occurs 1805 */ 1806 public java.sql.Time getTime(String columnName, Calendar cal) 1807 throws SQLException 1808 { 1809 NotImplemented(); 1810 return null; 1811 } 1812 1813 //--------------------------------------------------------------------- 1814 // JDBC 3.0 1815 //--------------------------------------------------------------------- 1816 1817 public URL getURL(int columnIndex) throws SQLException { 1818 throw new UnsupportedOperationException("ResultSet.getURL(int) unsupported"); 1819 } 1820 1821 public URL getURL(String columnName) throws SQLException { 1822 throw new UnsupportedOperationException("ResultSet.getURL(String) unsupported"); 1823 } 1824 1825 public void updateRef(int columnIndex, Ref x) throws SQLException { 1826 throw new UnsupportedOperationException("ResultSet.updateRef(int,java.sql.Ref) unsupported"); 1827 } 1828 1829 public void updateRef(String columnName, Ref x) throws SQLException { 1830 throw new UnsupportedOperationException("ResultSet.updateRef(String,java.sql.Ref) unsupported"); 1831 } 1832 1833 public void updateBlob(int columnIndex, Blob x) throws SQLException { 1834 throw new UnsupportedOperationException("ResultSet.updateBlob(int,java.sql.Blob) unsupported"); 1835 } 1836 1837 public void updateBlob(String columnName, Blob x) throws SQLException { 1838 throw new UnsupportedOperationException("ResultSet.updateBlob(String,java.sql.Blob) unsupported"); 1839 } 1840 1841 public void updateClob(int columnIndex, Clob x) throws SQLException { 1842 throw new UnsupportedOperationException("ResultSet.updateClob(int,java.sql.Clob) unsupported"); 1843 } 1844 1845 public void updateClob(String columnName, Clob x) throws SQLException { 1846 throw new UnsupportedOperationException("ResultSet.updateClob(String,java.sql.Clob) unsupported"); 1847 } 1848 1849 public void updateArray(int columnIndex, Array x) throws SQLException { 1850 throw new UnsupportedOperationException("ResultSet.updateArray(int,java.sql.Array) unsupported"); 1851 } 1852 1853 public void updateArray(String columnName, Array x) throws SQLException { 1854 throw new UnsupportedOperationException("ResultSet.updateArray(String,java.sql.Array) unsupported"); 1855 } 1856 1857 1858 1859 1860 }

This page was automatically generated by Maven