001/* ResultSet.java -- A SQL statement result set. 002 Copyright (C) 1999, 2000, 2002, 2006 Free Software Foundation, Inc. 003 004This file is part of GNU Classpath. 005 006GNU Classpath is free software; you can redistribute it and/or modify 007it under the terms of the GNU General Public License as published by 008the Free Software Foundation; either version 2, or (at your option) 009any later version. 010 011GNU Classpath is distributed in the hope that it will be useful, but 012WITHOUT ANY WARRANTY; without even the implied warranty of 013MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 014General Public License for more details. 015 016You should have received a copy of the GNU General Public License 017along with GNU Classpath; see the file COPYING. If not, write to the 018Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 01902110-1301 USA. 020 021Linking this library statically or dynamically with other modules is 022making a combined work based on this library. Thus, the terms and 023conditions of the GNU General Public License cover the whole 024combination. 025 026As a special exception, the copyright holders of this library give you 027permission to link this library with independent modules to produce an 028executable, regardless of the license terms of these independent 029modules, and to copy and distribute the resulting executable under 030terms of your choice, provided that you also meet, for each linked 031independent module, the terms and conditions of the license of that 032module. An independent module is a module which is not derived from 033or based on this library. If you modify this library, you may extend 034this exception to your version of the library, but you are not 035obligated to do so. If you do not wish to do so, delete this 036exception statement from your version. */ 037 038 039package java.sql; 040 041import java.io.InputStream; 042import java.io.Reader; 043import java.math.BigDecimal; 044import java.net.URL; 045import java.util.Calendar; 046import java.util.Map; 047 048/** 049 * This interface provides access to the data set returned by a SQL 050 * statement. An instance of this interface is returned by the various 051 * execution methods in the <code>Statement</code>. 052 * 053 * <p> This class models a cursor, which can be stepped through one row at a 054 * time. Methods are provided for accessing columns by column name or by 055 * index.</p> 056 * 057 * <p> Note that a result set is invalidated if the statement that returned 058 * it is closed.</p> 059 * 060 * @author Aaron M. Renn (arenn@urbanophile.com) 061 */ 062public interface ResultSet 063 extends AutoCloseable 064{ 065 /** 066 * The rows will be processed in order from first to last. 067 */ 068 int FETCH_FORWARD = 1000; 069 070 /** 071 * The rows will be processed in order from last to first. 072 */ 073 int FETCH_REVERSE = 1001; 074 075 /** 076 * The rows will be processed in an unknown order 077 */ 078 int FETCH_UNKNOWN = 1002; 079 080 /** 081 * This type of result set may only step forward through the rows returned. 082 */ 083 int TYPE_FORWARD_ONLY = 1003; 084 085 /** 086 * This type of result set is scrollable and is not sensitive to changes 087 * made by other statements. 088 */ 089 int TYPE_SCROLL_INSENSITIVE = 1004; 090 091 /** 092 * This type of result set is scrollable and is also sensitive to changes 093 * made by other statements. 094 */ 095 int TYPE_SCROLL_SENSITIVE = 1005; 096 097 /** 098 * The concurrency mode of for the result set may not be modified. 099 */ 100 int CONCUR_READ_ONLY = 1007; 101 102 /** 103 * The concurrency mode of for the result set may be modified. 104 */ 105 int CONCUR_UPDATABLE = 1008; 106 107 int HOLD_CURSORS_OVER_COMMIT = 1; 108 109 int CLOSE_CURSORS_AT_COMMIT = 2; 110 111 /** 112 * This method advances to the next row in the result set. Any streams 113 * open on the current row are closed automatically. 114 * 115 * @return <code>true</code> if the next row exists, <code>false</code> 116 * otherwise. 117 * @exception SQLException If an error occurs. 118 */ 119 boolean next() throws SQLException; 120 121 /** 122 * This method closes the result set and frees any associated resources. 123 * 124 * @exception SQLException If an error occurs. 125 */ 126 void close() throws SQLException; 127 128 /** 129 * This method tests whether the value of the last column that was fetched 130 * was actually a SQL NULL value. 131 * 132 * @return <code>true</code> if the last column fetched was a NULL, 133 * <code>false</code> otherwise. 134 * @exception SQLException If an error occurs. 135 */ 136 boolean wasNull() throws SQLException; 137 138 /** 139 * This method returns the value of the specified column as a Java 140 * <code>String</code>. 141 * 142 * @param columnIndex The index of the column to return. 143 * @return The column value as a <code>String</code>. 144 * @exception SQLException If an error occurs. 145 */ 146 String getString(int columnIndex) throws SQLException; 147 148 /** 149 * This method returns the value of the specified column as a Java 150 * <code>boolean</code>. 151 * 152 * @param columnIndex The index of the column to return. 153 * @return The column value as a <code>boolean</code>. 154 * @exception SQLException If an error occurs. 155 */ 156 boolean getBoolean(int columnIndex) throws SQLException; 157 158 /** 159 * This method returns the value of the specified column as a Java 160 * <code>byte</code>. 161 * 162 * @param columnIndex The index of the column to return. 163 * @return The column value as a <code>byte</code>. 164 * @exception SQLException If an error occurs. 165 */ 166 byte getByte(int columnIndex) throws SQLException; 167 168 /** 169 * This method returns the value of the specified column as a Java 170 * <code>short</code>. 171 * 172 * @param columnIndex The index of the column to return. 173 * @return The column value as a <code>short</code>. 174 * @exception SQLException If an error occurs. 175 */ 176 short getShort(int columnIndex) throws SQLException; 177 178 /** 179 * This method returns the value of the specified column as a Java 180 * <code>int</code>. 181 * 182 * @param columnIndex The index of the column to return. 183 * @return The column value as a <code>int</code>. 184 * @exception SQLException If an error occurs. 185 */ 186 int getInt(int columnIndex) throws SQLException; 187 188 /** 189 * This method returns the value of the specified column as a Java 190 * <code>long</code>. 191 * 192 * @param columnIndex The index of the column to return. 193 * @return The column value as a <code>long</code>. 194 * @exception SQLException If an error occurs. 195 */ 196 long getLong(int columnIndex) throws SQLException; 197 198 /** 199 * This method returns the value of the specified column as a Java 200 * <code>float</code>. 201 * 202 * @param columnIndex The index of the column to return. 203 * @return The column value as a <code>float</code>. 204 * @exception SQLException If an error occurs. 205 */ 206 float getFloat(int columnIndex) throws SQLException; 207 208 /** 209 * This method returns the value of the specified column as a Java 210 * <code>double</code>. 211 * 212 * @param columnIndex The index of the column to return. 213 * @return The column value as a <code>double</code>. 214 * @exception SQLException If an error occurs. 215 */ 216 double getDouble(int columnIndex) throws SQLException; 217 218 /** 219 * This method returns the value of the specified column as a Java 220 * <code>BigDecimal</code>. 221 * 222 * @param columnIndex The index of the column to return. 223 * @param scale The number of digits to the right of the decimal to return. 224 * @return The column value as a <code>BigDecimal</code>. 225 * @exception SQLException If an error occurs. 226 * @deprecated 227 */ 228 BigDecimal getBigDecimal(int columnIndex, int scale) 229 throws SQLException; 230 231 /** 232 * This method returns the value of the specified column as a Java 233 * byte array. 234 * 235 * @param columnIndex The index of the column to return. 236 * @return The column value as a byte array 237 * @exception SQLException If an error occurs. 238 */ 239 byte[] getBytes(int columnIndex) throws SQLException; 240 241 /** 242 * This method returns the value of the specified column as a Java 243 * <code>java.sql.Date</code>. 244 * 245 * @param columnIndex The index of the column to return. 246 * @return The column value as a <code>java.sql.Date</code>. 247 * @exception SQLException If an error occurs. 248 */ 249 Date getDate(int columnIndex) throws SQLException; 250 251 /** 252 * This method returns the value of the specified column as a Java 253 * <code>java.sql.Time</code>. 254 * 255 * @param columnIndex The index of the column to return. 256 * @return The column value as a <code>java.sql.Time</code>. 257 * @exception SQLException If an error occurs. 258 */ 259 Time getTime(int columnIndex) throws SQLException; 260 261 /** 262 * This method returns the value of the specified column as a Java 263 * <code>java.sql.Timestamp</code>. 264 * 265 * @param columnIndex The index of the column to return. 266 * @return The column value as a <code>java.sql.Timestamp</code>. 267 * @exception SQLException If an error occurs. 268 */ 269 Timestamp getTimestamp(int columnIndex) throws SQLException; 270 271 /** 272 * This method returns the value of the specified column as an ASCII 273 * stream. Note that all the data from this stream must be read before 274 * fetching the value of any other column. Please also be aware that 275 * calling <code>next()</code> or <code>close()</code> on this result set 276 * will close this stream as well. 277 * 278 * @param columnIndex The index of the column to return. 279 * @return The column value as an ASCII <code>InputStream</code>. 280 * @exception SQLException If an error occurs. 281 */ 282 InputStream getAsciiStream(int columnIndex) throws SQLException; 283 284 /** 285 * This method returns the value of the specified column as a Unicode UTF-8 286 * stream. Note that all the data from this stream must be read before 287 * fetching the value of any other column. Please also be aware that 288 * calling <code>next()</code> or <code>close()</code> on this result set 289 * will close this stream as well. 290 * 291 * @param columnIndex The index of the column to return. 292 * @return The column value as a Unicode UTF-8 <code>InputStream</code>. 293 * @exception SQLException If an error occurs. 294 * @deprecated Use getCharacterStream instead. 295 */ 296 InputStream getUnicodeStream(int columnIndex) throws SQLException; 297 298 /** 299 * This method returns the value of the specified column as a raw byte 300 * stream. Note that all the data from this stream must be read before 301 * fetching the value of any other column. Please also be aware that 302 * calling <code>next()</code> or <code>close()</code> on this result set 303 * will close this stream as well. 304 * 305 * @param columnIndex The index of the column to return. 306 * @return The column value as a raw byte <code>InputStream</code>. 307 * @exception SQLException If an error occurs. 308 */ 309 InputStream getBinaryStream(int columnIndex) throws SQLException; 310 311 /** 312 * This method returns the value of the specified column as a Java 313 * <code>String</code>. 314 * 315 * @param columnName The name of the column to return. 316 * @return The column value as a <code>String</code>. 317 * @exception SQLException If an error occurs. 318 */ 319 String getString(String columnName) throws SQLException; 320 321 /** 322 * This method returns the value of the specified column as a Java 323 * <code>boolean</code>. 324 * 325 * @param columnName The name of the column to return. 326 * @return The column value as a <code>boolean</code>. 327 * @exception SQLException If an error occurs. 328 */ 329 boolean getBoolean(String columnName) throws SQLException; 330 331 /** 332 * This method returns the value of the specified column as a Java 333 * <code>byte</code>. 334 * 335 * @param columnName The name of the column to return. 336 * @return The column value as a <code>byte</code>. 337 * @exception SQLException If an error occurs. 338 */ 339 byte getByte(String columnName) throws SQLException; 340 341 /** 342 * This method returns the value of the specified column as a Java 343 * <code>short</code>. 344 * 345 * @param columnName The name of the column to return. 346 * @return The column value as a <code>short</code>. 347 * @exception SQLException If an error occurs. 348 */ 349 short getShort(String columnName) throws SQLException; 350 351 /** 352 * This method returns the value of the specified column as a Java 353 * <code>int</code>. 354 * 355 * @param columnName The name of the column to return. 356 * @return The column value as a <code>int</code>. 357 * @exception SQLException If an error occurs. 358 */ 359 int getInt(String columnName) throws SQLException; 360 361 /** 362 * This method returns the value of the specified column as a Java 363 * <code>long</code>. 364 * 365 * @param columnName The name of the column to return. 366 * @return The column value as a <code>long</code>. 367 * @exception SQLException If an error occurs. 368 */ 369 long getLong(String columnName) throws SQLException; 370 371 /** 372 * This method returns the value of the specified column as a Java 373 * <code>float</code>. 374 * 375 * @param columnName The name of the column to return. 376 * @return The column value as a <code>float</code>. 377 * @exception SQLException If an error occurs. 378 */ 379 float getFloat(String columnName) throws SQLException; 380 381 /** 382 * This method returns the value of the specified column as a Java 383 * <code>double</code>. 384 * 385 * @param columnName The name of the column to return. 386 * @return The column value as a <code>double</code>. 387 * @exception SQLException If an error occurs. 388 */ 389 double getDouble(String columnName) throws SQLException; 390 391 /** 392 * This method returns the value of the specified column as a Java 393 * <code>BigDecimal</code>. 394 * 395 * @param columnName The name of the column to return. 396 * @return The column value as a <code>BigDecimal</code>. 397 * @exception SQLException If an error occurs. 398 * @deprecated 399 */ 400 BigDecimal getBigDecimal(String columnName, int scale) 401 throws SQLException; 402 403 /** 404 * This method returns the value of the specified column as a Java 405 * byte array. 406 * 407 * @param columnName The name of the column to return. 408 * @return The column value as a byte array 409 * @exception SQLException If an error occurs. 410 */ 411 byte[] getBytes(String columnName) throws SQLException; 412 413 /** 414 * This method returns the value of the specified column as a Java 415 * <code>java.sql.Date</code>. 416 * 417 * @param columnName The name of the column to return. 418 * @return The column value as a <code>java.sql.Date</code>. 419 * @exception SQLException If an error occurs. 420 */ 421 Date getDate(String columnName) throws SQLException; 422 423 /** 424 * This method returns the value of the specified column as a Java 425 * <code>java.sql.Time</code>. 426 * 427 * @param columnName The name of the column to return. 428 * @return The column value as a <code>java.sql.Time</code>. 429 * @exception SQLException If an error occurs. 430 */ 431 Time getTime(String columnName) throws SQLException; 432 433 /** 434 * This method returns the value of the specified column as a Java 435 * <code>java.sql.Timestamp</code>. 436 * 437 * @param columnName The name of the column to return. 438 * @return The column value as a <code>java.sql.Timestamp</code>. 439 * @exception SQLException If an error occurs. 440 */ 441 Timestamp getTimestamp(String columnName) throws SQLException; 442 443 /** 444 * This method returns the value of the specified column as an ASCII 445 * stream. Note that all the data from this stream must be read before 446 * fetching the value of any other column. Please also be aware that 447 * calling <code>next()</code> or <code>close()</code> on this result set 448 * will close this stream as well. 449 * 450 * @param columnName The name of the column to return. 451 * @return The column value as an ASCII <code>InputStream</code>. 452 * @exception SQLException If an error occurs. 453 */ 454 InputStream getAsciiStream(String columnName) throws SQLException; 455 456 /** 457 * This method returns the value of the specified column as a Unicode UTF-8 458 * stream. Note that all the data from this stream must be read before 459 * fetching the value of any other column. Please also be aware that 460 * calling <code>next()</code> or <code>close()</code> on this result set 461 * will close this stream as well. 462 * 463 * @param columnName The name of the column to return. 464 * @return The column value as a Unicode UTF-8 <code>InputStream</code>. 465 * @exception SQLException If an error occurs. 466 * @deprecated Use getCharacterStream instead. 467 */ 468 InputStream getUnicodeStream(String columnName) throws SQLException; 469 470 /** 471 * This method returns the value of the specified column as a raw byte 472 * stream. Note that all the data from this stream must be read before 473 * fetching the value of any other column. Please also be aware that 474 * calling <code>next()</code> or <code>close()</code> on this result set 475 * will close this stream as well. 476 * 477 * @param columnName The name of the column to return. 478 * @return The column value as a raw byte <code>InputStream</code>. 479 * @exception SQLException If an error occurs. 480 */ 481 InputStream getBinaryStream(String columnName) throws SQLException; 482 483 /** 484 * This method returns the first SQL warning associated with this result 485 * set. Any additional warnings will be chained to this one. 486 * 487 * @return The first SQLWarning for this result set, or <code>null</code> if 488 * there are no warnings. 489 * @exception SQLException If an error occurs. 490 */ 491 SQLWarning getWarnings() throws SQLException; 492 493 /** 494 * This method clears all warnings associated with this result set. 495 * 496 * @exception SQLException If an error occurs. 497 */ 498 void clearWarnings() throws SQLException; 499 500 /** 501 * This method returns the name of the database cursor used by this 502 * result set. 503 * 504 * @return The name of the database cursor used by this result set. 505 * @exception SQLException If an error occurs. 506 */ 507 String getCursorName() throws SQLException; 508 509 /** 510 * This method returns data about the columns returned as part of the 511 * result set as a <code>ResultSetMetaData</code> instance. 512 * 513 * @return The <code>ResultSetMetaData</code> instance for this result set. 514 * @exception SQLException If an error occurs. 515 */ 516 ResultSetMetaData getMetaData() throws SQLException; 517 518 /** 519 * This method returns the value of the specified column as a Java 520 * <code>Object</code>. 521 * 522 * @param columnIndex The index of the column to return. 523 * @return The column value as an <code>Object</code>. 524 * @exception SQLException If an error occurs. 525 */ 526 Object getObject(int columnIndex) throws SQLException; 527 528 /** 529 * This method returns the value of the specified column as a Java 530 * <code>Object</code>. 531 * 532 * @param columnName The name of the column to return. 533 * @return The column value as an <code>Object</code>. 534 * @exception SQLException If an error occurs. 535 */ 536 Object getObject(String columnName) throws SQLException; 537 538 /** 539 * This method returns the column index of the specified named column. 540 * 541 * @param columnName The name of the column. 542 * @return The index of the column. 543 * @exception SQLException If an error occurs. 544 */ 545 int findColumn(String columnName) throws SQLException; 546 547 /** 548 * This method returns the value of the specified column as a character 549 * stream. Note that all the data from this stream must be read before 550 * fetching the value of any other column. Please also be aware that 551 * calling <code>next()</code> or <code>close()</code> on this result set 552 * will close this stream as well. 553 * 554 * @param columnIndex The index of the column to return. 555 * @return The column value as an character <code>Reader</code>. 556 * @exception SQLException If an error occurs. 557 */ 558 Reader getCharacterStream(int columnIndex) throws SQLException; 559 560 /** 561 * This method returns the value of the specified column as a character 562 * stream. Note that all the data from this stream must be read before 563 * fetching the value of any other column. Please also be aware that 564 * calling <code>next()</code> or <code>close()</code> on this result set 565 * will close this stream as well. 566 * 567 * @param columnName The name of the column to return. 568 * @return The column value as an character <code>Reader</code>. 569 * @exception SQLException If an error occurs. 570 */ 571 Reader getCharacterStream(String columnName) throws SQLException; 572 573 /** 574 * This method returns the value of the specified column as a Java 575 * <code>BigDecimal</code>. 576 * 577 * @param columnIndex The index of the column to return. 578 * @return The column value as a <code>BigDecimal</code>. 579 * @exception SQLException If an error occurs. 580 */ 581 BigDecimal getBigDecimal(int columnIndex) throws SQLException; 582 583 /** 584 * This method returns the value of the specified column as a Java 585 * <code>BigDecimal</code>. 586 * 587 * @param columnName The name of the column to return. 588 * @return The column value as a <code>BigDecimal</code>. 589 * @exception SQLException If an error occurs. 590 */ 591 BigDecimal getBigDecimal(String columnName) throws SQLException; 592 593 /** 594 * This method tests whether or not the cursor is before the first row 595 * in the result set. 596 * 597 * @return <code>true</code> if the cursor is positioned before the first 598 * row, <code>false</code> otherwise. 599 * @exception SQLException If an error occurs. 600 */ 601 boolean isBeforeFirst() throws SQLException; 602 603 /** 604 * This method tests whether or not the cursor is after the last row 605 * in the result set. 606 * 607 * @return <code>true</code> if the cursor is positioned after the last 608 * row, <code>false</code> otherwise. 609 * @exception SQLException If an error occurs. 610 */ 611 boolean isAfterLast() throws SQLException; 612 613 /** 614 * This method tests whether or not the cursor is positioned on the first 615 * row in the result set. 616 * 617 * @return <code>true</code> if the cursor is positioned on the first 618 * row, <code>false</code> otherwise. 619 * @exception SQLException If an error occurs. 620 */ 621 boolean isFirst() throws SQLException; 622 623 /** 624 * This method tests whether or not the cursor is on the last row 625 * in the result set. 626 * 627 * @return <code>true</code> if the cursor is positioned on the last 628 * row, <code>false</code> otherwise. 629 * @exception SQLException If an error occurs. 630 */ 631 boolean isLast() throws SQLException; 632 633 /** 634 * This method repositions the cursor to before the first row in the 635 * result set. 636 * 637 * @exception SQLException If an error occurs. 638 */ 639 void beforeFirst() throws SQLException; 640 641 /** 642 * This method repositions the cursor to after the last row in the result 643 * set. 644 * 645 * @exception SQLException If an error occurs. 646 */ 647 void afterLast() throws SQLException; 648 649 /** 650 * This method repositions the cursor on the first row in the 651 * result set. 652 * 653 * @return <code>true</code> if the cursor is on a valid row; 654 * <code>false</code> if there are no rows in the result set. 655 * @exception SQLException If an error occurs. 656 */ 657 boolean first() throws SQLException; 658 659 /** 660 * This method repositions the cursor on the last row in the result 661 * set. 662 * 663 * @return <code>true</code> if the cursor is on a valid row; 664 * <code>false</code> if there are no rows in the result set. 665 * @exception SQLException If an error occurs. 666 */ 667 boolean last() throws SQLException; 668 669 /** 670 * This method returns the current row number in the cursor. Numbering 671 * begins at index 1. 672 * 673 * @return The current row number, or 0 if there is not current row. 674 * @exception SQLException If an error occurs. 675 */ 676 int getRow() throws SQLException; 677 678 /** 679 * This method positions the result set to the specified absolute row. 680 * Positive numbers are row offsets from the beginning of the result 681 * set (numbering starts from row 1) and negative numbers are row offsets 682 * from the end of the result set (numbering starts from -1). 683 * 684 * @param row The row to position the result set to. 685 * 686 * @return <code>true</code> if the current position was changed, 687 * <code>false</code> otherwise. 688 * @exception SQLException If an error occurs. 689 */ 690 boolean absolute(int row) throws SQLException; 691 692 /** 693 * This method moves the result set position relative to the current row. 694 * The offset can be positive or negative. 695 * 696 * @param rows The number of row positions to move. 697 * @return <code>true</code> if the current position was changed, 698 * <code>false</code> otherwise. 699 * @exception SQLException If an error occurs. 700 */ 701 boolean relative(int rows) throws SQLException; 702 703 /** 704 * This method moves the current position to the previous row in the 705 * result set. 706 * 707 * @return <code>true</code> if the previous row exists, <code>false</code> 708 * otherwise. 709 * @exception SQLException If an error occurs. 710 */ 711 boolean previous() throws SQLException; 712 713 /** 714 * This method provides a hint to the driver about which direction the 715 * result set will be processed in. 716 * 717 * @param direction The direction in which rows will be processed. The 718 * allowed values are the <code>FETCH_*</code> constants 719 * defined in this interface. 720 * @exception SQLException If an error occurs. 721 */ 722 void setFetchDirection(int direction) throws SQLException; 723 724 /** 725 * This method returns the current fetch direction for this result set. 726 * 727 * @return The fetch direction for this result set. 728 * @exception SQLException If an error occurs. 729 */ 730 int getFetchDirection() throws SQLException; 731 732 /** 733 * This method provides a hint to the driver about how many rows at a 734 * time it should fetch from the database. 735 * 736 * @param rows The number of rows the driver should fetch per call. 737 * @exception SQLException If an error occurs. 738 */ 739 void setFetchSize(int rows) throws SQLException; 740 741 /** 742 * This method returns the current number of rows that will be fetched 743 * from the database at a time. 744 * 745 * @return The current fetch size for this result set. 746 * @exception SQLException If an error occurs. 747 */ 748 int getFetchSize() throws SQLException; 749 750 /** 751 * This method returns the result set type of this result set. This will 752 * be one of the <code>TYPE_*</code> constants defined in this interface. 753 * 754 * @return The result set type. 755 * @exception SQLException If an error occurs. 756 */ 757 int getType() throws SQLException; 758 759 /** 760 * This method returns the concurrency type of this result set. This will 761 * be one of the <code>CONCUR_*</code> constants defined in this interface. 762 * 763 * @return The result set concurrency type. 764 * @exception SQLException If an error occurs. 765 */ 766 int getConcurrency() throws SQLException; 767 768 /** 769 * This method tests whether or not the current row in the result set 770 * has been updated. Updates must be visible in order of this method to 771 * detect the update. 772 * 773 * @return <code>true</code> if the row has been updated, <code>false</code> 774 * otherwise. 775 * @exception SQLException If an error occurs. 776 */ 777 boolean rowUpdated() throws SQLException; 778 779 /** 780 * This method tests whether or not the current row in the result set 781 * has been inserted. Inserts must be visible in order of this method to 782 * detect the insert. 783 * 784 * @return <code>true</code> if the row has been inserted, <code>false</code> 785 * otherwise. 786 * @exception SQLException If an error occurs. 787 */ 788 boolean rowInserted() throws SQLException; 789 790 /** 791 * This method tests whether or not the current row in the result set 792 * has been deleted. Deletes must be visible in order of this method to 793 * detect the deletion. 794 * 795 * @return <code>true</code> if the row has been deleted, <code>false</code> 796 * otherwise. 797 * @exception SQLException If an error occurs. 798 */ 799 boolean rowDeleted() throws SQLException; 800 801 /** 802 * This method updates the specified column to have a NULL value. This 803 * does not update the actual database. <code>updateRow</code> must be 804 * called in order to do that. 805 * 806 * @param columnIndex The index of the column to update. 807 * @exception SQLException If an error occurs. 808 */ 809 void updateNull(int columnIndex) throws SQLException; 810 811 /** 812 * This method updates the specified column to have a boolean value. This 813 * does not update the actual database. <code>updateRow</code> must be 814 * called in order to do that. 815 * 816 * @param columnIndex The index of the column to update. 817 * @param value The new value of the column. 818 * @exception SQLException If an error occurs. 819 */ 820 void updateBoolean(int columnIndex, boolean value) throws SQLException; 821 822 /** 823 * This method updates the specified column to have a byte value. This 824 * does not update the actual database. <code>updateRow</code> must be 825 * called in order to do that. 826 * 827 * @param columnIndex The index of the column to update. 828 * @param value The new value of the column. 829 * @exception SQLException If an error occurs. 830 */ 831 void updateByte(int columnIndex, byte value) throws SQLException; 832 833 /** 834 * This method updates the specified column to have a short value. This 835 * does not update the actual database. <code>updateRow</code> must be 836 * called in order to do that. 837 * 838 * @param columnIndex The index of the column to update. 839 * @param value The new value of the column. 840 * @exception SQLException If an error occurs. 841 */ 842 void updateShort(int columnIndex, short value) throws SQLException; 843 844 /** 845 * This method updates the specified column to have an int value. This 846 * does not update the actual database. <code>updateRow</code> must be 847 * called in order to do that. 848 * 849 * @param columnIndex The index of the column to update. 850 * @param value The new value of the column. 851 * @exception SQLException If an error occurs. 852 */ 853 void updateInt(int columnIndex, int value) throws SQLException; 854 855 /** 856 * This method updates the specified column to have a long value. This 857 * does not update the actual database. <code>updateRow</code> must be 858 * called in order to do that. 859 * 860 * @param columnIndex The index of the column to update. 861 * @param value The new value of the column. 862 * @exception SQLException If an error occurs. 863 */ 864 void updateLong(int columnIndex, long value) throws SQLException; 865 866 /** 867 * This method updates the specified column to have a float value. This 868 * does not update the actual database. <code>updateRow</code> must be 869 * called in order to do that. 870 * 871 * @param columnIndex The index of the column to update. 872 * @param value The new value of the column. 873 * @exception SQLException If an error occurs. 874 */ 875 void updateFloat(int columnIndex, float value) throws SQLException; 876 877 /** 878 * This method updates the specified column to have a double value. This 879 * does not update the actual database. <code>updateRow</code> must be 880 * called in order to do that. 881 * 882 * @param columnIndex The index of the column to update. 883 * @param value The new value of the column. 884 * @exception SQLException If an error occurs. 885 */ 886 void updateDouble(int columnIndex, double value) throws SQLException; 887 888 /** 889 * This method updates the specified column to have a BigDecimal value. This 890 * does not update the actual database. <code>updateRow</code> must be 891 * called in order to do that. 892 * 893 * @param columnIndex The index of the column to update. 894 * @param value The new value of the column. 895 * @exception SQLException If an error occurs. 896 */ 897 void updateBigDecimal(int columnIndex, BigDecimal value) 898 throws SQLException; 899 900 /** 901 * This method updates the specified column to have a String value. This 902 * does not update the actual database. <code>updateRow</code> must be 903 * called in order to do that. 904 * 905 * @param columnIndex The index of the column to update. 906 * @param value The new value of the column. 907 * @exception SQLException If an error occurs. 908 */ 909 void updateString(int columnIndex, String value) throws SQLException; 910 911 /** 912 * This method updates the specified column to have a byte array value. This 913 * does not update the actual database. <code>updateRow</code> must be 914 * called in order to do that. 915 * 916 * @param columnIndex The index of the column to update. 917 * @param value The new value of the column. 918 * @exception SQLException If an error occurs. 919 */ 920 void updateBytes(int columnIndex, byte[] value) throws SQLException; 921 922 /** 923 * This method updates the specified column to have a java.sql.Date value. This 924 * does not update the actual database. <code>updateRow</code> must be 925 * called in order to do that. 926 * 927 * @param columnIndex The index of the column to update. 928 * @param value The new value of the column. 929 * @exception SQLException If an error occurs. 930 */ 931 void updateDate(int columnIndex, Date value) throws SQLException; 932 933 /** 934 * This method updates the specified column to have a java.sql.Time value. This 935 * does not update the actual database. <code>updateRow</code> must be 936 * called in order to do that. 937 * 938 * @param columnIndex The index of the column to update. 939 * @param value The new value of the column. 940 * @exception SQLException If an error occurs. 941 */ 942 void updateTime(int columnIndex, Time value) throws SQLException; 943 944 /** 945 * This method updates the specified column to have a java.sql.Timestamp value. 946 * This does not update the actual database. <code>updateRow</code> must be 947 * called in order to do that. 948 * 949 * @param columnIndex The index of the column to update. 950 * @param value The new value of the column. 951 * @exception SQLException If an error occurs. 952 */ 953 void updateTimestamp(int columnIndex, Timestamp value) 954 throws SQLException; 955 956 /** 957 * This method updates the specified column from an ASCII text stream. 958 * This does not update the actual database. <code>updateRow</code> must be 959 * called in order to do that. 960 * 961 * @param columnIndex The index of the column to update. 962 * @param stream The stream from which the column value is updated. 963 * @param count The length of the stream. 964 * @exception SQLException If an error occurs. 965 */ 966 void updateAsciiStream(int columnIndex, InputStream stream, int count) 967 throws SQLException; 968 969 /** 970 * This method updates the specified column from a binary stream. 971 * This does not update the actual database. <code>updateRow</code> must be 972 * called in order to do that. 973 * 974 * @param columnIndex The index of the column to update. 975 * @param stream The stream from which the column value is updated. 976 * @param count The length of the stream. 977 * @exception SQLException If an error occurs. 978 */ 979 void updateBinaryStream(int columnIndex, InputStream stream, int count) 980 throws SQLException; 981 982 /** 983 * This method updates the specified column from a character stream. 984 * This does not update the actual database. <code>updateRow</code> must be 985 * called in order to do that. 986 * 987 * @param columnIndex The index of the column to update. 988 * @param reader The reader from which the column value is updated. 989 * @param count The length of the stream. 990 * @exception SQLException If an error occurs. 991 */ 992 void updateCharacterStream(int columnIndex, Reader reader, int count) 993 throws SQLException; 994 995 /** 996 * This method updates the specified column to have an Object value. 997 * This does not update the actual database. <code>updateRow</code> must be 998 * called in order to do that. 999 * 1000 * @param columnIndex The index of the column to update. 1001 * @param value The new value of the column. 1002 * @param scale The scale of the object in question, which is used only 1003 * for numeric type objects. 1004 * @exception SQLException If an error occurs. 1005 */ 1006 void updateObject(int columnIndex, Object value, int scale) 1007 throws SQLException; 1008 1009 /** 1010 * This method updates the specified column to have an Object value. 1011 * This does not update the actual database. <code>updateRow</code> must be 1012 * called in order to do that. 1013 * 1014 * @param columnIndex The index of the column to update. 1015 * @param value The new value of the column. 1016 * @exception SQLException If an error occurs. 1017 */ 1018 void updateObject(int columnIndex, Object value) throws SQLException; 1019 1020 /** 1021 * This method updates the specified column to have a NULL value. This 1022 * does not update the actual database. <code>updateRow</code> must be 1023 * called in order to do that. 1024 * 1025 * @param columnName The name of the column to update. 1026 * @exception SQLException If an error occurs. 1027 */ 1028 void updateNull(String columnName) throws SQLException; 1029 1030 /** 1031 * This method updates the specified column to have a boolean value. This 1032 * does not update the actual database. <code>updateRow</code> must be 1033 * called in order to do that. 1034 * 1035 * @param columnName The name of the column to update. 1036 * @param value The new value of the column. 1037 * @exception SQLException If an error occurs. 1038 */ 1039 void updateBoolean(String columnName, boolean value) throws SQLException; 1040 1041 /** 1042 * This method updates the specified column to have a byte value. This 1043 * does not update the actual database. <code>updateRow</code> must be 1044 * called in order to do that. 1045 * 1046 * @param columnName The name of the column to update. 1047 * @param value The new value of the column. 1048 * @exception SQLException If an error occurs. 1049 */ 1050 void updateByte(String columnName, byte value) throws SQLException; 1051 1052 /** 1053 * This method updates the specified column to have a short value. This 1054 * does not update the actual database. <code>updateRow</code> must be 1055 * called in order to do that. 1056 * 1057 * @param columnName The name of the column to update. 1058 * @param value The new value of the column. 1059 * @exception SQLException If an error occurs. 1060 */ 1061 void updateShort(String columnName, short value) throws SQLException; 1062 1063 /** 1064 * This method updates the specified column to have an int value. This 1065 * does not update the actual database. <code>updateRow</code> must be 1066 * called in order to do that. 1067 * 1068 * @param columnName The name of the column to update. 1069 * @param value The new value of the column. 1070 * @exception SQLException If an error occurs. 1071 */ 1072 void updateInt(String columnName, int value) throws SQLException; 1073 1074 /** 1075 * This method updates the specified column to have a long value. This 1076 * does not update the actual database. <code>updateRow</code> must be 1077 * called in order to do that. 1078 * 1079 * @param columnName The name of the column to update. 1080 * @param value The new value of the column. 1081 * @exception SQLException If an error occurs. 1082 */ 1083 void updateLong(String columnName, long value) throws SQLException; 1084 1085 /** 1086 * This method updates the specified column to have a float value. This 1087 * does not update the actual database. <code>updateRow</code> must be 1088 * called in order to do that. 1089 * 1090 * @param columnName The name of the column to update. 1091 * @param value The new value of the column. 1092 * @exception SQLException If an error occurs. 1093 */ 1094 void updateFloat(String columnName, float value) throws SQLException; 1095 1096 /** 1097 * This method updates the specified column to have a double value. This 1098 * does not update the actual database. <code>updateRow</code> must be 1099 * called in order to do that. 1100 * 1101 * @param columnName The name of the column to update. 1102 * @param value The new value of the column. 1103 * @exception SQLException If an error occurs. 1104 */ 1105 void updateDouble(String columnName, double value) throws SQLException; 1106 1107 /** 1108 * This method updates the specified column to have a BigDecimal value. This 1109 * does not update the actual database. <code>updateRow</code> must be 1110 * called in order to do that. 1111 * 1112 * @param columnName The name of the column to update. 1113 * @param value The new value of the column. 1114 * @exception SQLException If an error occurs. 1115 */ 1116 void updateBigDecimal(String columnName, BigDecimal value) 1117 throws SQLException; 1118 1119 /** 1120 * This method updates the specified column to have a String value. This 1121 * does not update the actual database. <code>updateRow</code> must be 1122 * called in order to do that. 1123 * 1124 * @param columnName The name of the column to update. 1125 * @param value The new value of the column. 1126 * @exception SQLException If an error occurs. 1127 */ 1128 void updateString(String columnName, String value) throws SQLException; 1129 1130 /** 1131 * This method updates the specified column to have a byte array value. This 1132 * does not update the actual database. <code>updateRow</code> must be 1133 * called in order to do that. 1134 * 1135 * @param columnName The name of the column to update. 1136 * @param value The new value of the column. 1137 * @exception SQLException If an error occurs. 1138 */ 1139 void updateBytes(String columnName, byte[] value) throws SQLException; 1140 1141 /** 1142 * This method updates the specified column to have a java.sql.Date value. This 1143 * does not update the actual database. <code>updateRow</code> must be 1144 * called in order to do that. 1145 * 1146 * @param columnName The name of the column to update. 1147 * @param value The new value of the column. 1148 * @exception SQLException If an error occurs. 1149 */ 1150 void updateDate(String columnName, Date value) throws SQLException; 1151 1152 /** 1153 * This method updates the specified column to have a java.sql.Time value. This 1154 * does not update the actual database. <code>updateRow</code> must be 1155 * called in order to do that. 1156 * 1157 * @param columnName The name of the column to update. 1158 * @param value The new value of the column. 1159 * @exception SQLException If an error occurs. 1160 */ 1161 void updateTime(String columnName, Time value) throws SQLException; 1162 1163 /** 1164 * This method updates the specified column to have a java.sql.Timestamp value. 1165 * This does not update the actual database. <code>updateRow</code> must be 1166 * called in order to do that. 1167 * 1168 * @param columnName The name of the column to update. 1169 * @param value The new value of the column. 1170 * @exception SQLException If an error occurs. 1171 */ 1172 void updateTimestamp(String columnName, Timestamp value) 1173 throws SQLException; 1174 1175 /** 1176 * This method updates the specified column from an ASCII text stream. 1177 * This does not update the actual database. <code>updateRow</code> must be 1178 * called in order to do that. 1179 * 1180 * @param columnName The name of the column to update. 1181 * @param stream The stream from which the column value is updated. 1182 * @param count The length of the stream. 1183 * @exception SQLException If an error occurs. 1184 */ 1185 void updateAsciiStream(String columnName, InputStream stream, int count) 1186 throws SQLException; 1187 1188 /** 1189 * This method updates the specified column from a binary stream. 1190 * This does not update the actual database. <code>updateRow</code> must be 1191 * called in order to do that. 1192 * 1193 * @param columnName The name of the column to update. 1194 * @param stream The stream from which the column value is updated. 1195 * @param count The length of the stream. 1196 * @exception SQLException If an error occurs. 1197 */ 1198 void updateBinaryStream(String columnName, InputStream stream, int count) 1199 throws SQLException; 1200 1201 /** 1202 * This method updates the specified column from a character stream. 1203 * This does not update the actual database. <code>updateRow</code> must be 1204 * called in order to do that. 1205 * 1206 * @param columnName The name of the column to update. 1207 * @param reader The reader from which the column value is updated. 1208 * @param count The length of the stream. 1209 * @exception SQLException If an error occurs. 1210 */ 1211 void updateCharacterStream(String columnName, Reader reader, int count) 1212 throws SQLException; 1213 1214 /** 1215 * This method updates the specified column to have an Object value. 1216 * This does not update the actual database. <code>updateRow</code> must be 1217 * called in order to do that. 1218 * 1219 * @param columnName The name of the column to update. 1220 * @param value The new value of the column. 1221 * @param scale The scale of the object in question, which is used only 1222 * for numeric type objects. 1223 * @exception SQLException If an error occurs. 1224 */ 1225 void updateObject(String columnName, Object value, int scale) 1226 throws SQLException; 1227 1228 /** 1229 * This method updates the specified column to have an Object value. 1230 * This does not update the actual database. <code>updateRow</code> must be 1231 * called in order to do that. 1232 * 1233 * @param columnName The name of the column to update. 1234 * @param value The new value of the column. 1235 * @exception SQLException If an error occurs. 1236 */ 1237 void updateObject(String columnName, Object value) throws SQLException; 1238 1239 /** 1240 * This method inserts the current row into the database. The result set 1241 * must be positioned on the insert row in order to call this method 1242 * successfully. 1243 * 1244 * @exception SQLException If an error occurs. 1245 */ 1246 void insertRow() throws SQLException; 1247 1248 /** 1249 * This method updates the current row in the database. 1250 * 1251 * @exception SQLException If an error occurs. 1252 */ 1253 void updateRow() throws SQLException; 1254 1255 /** 1256 * This method deletes the current row in the database. 1257 * 1258 * @exception SQLException If an error occurs. 1259 */ 1260 void deleteRow() throws SQLException; 1261 1262 /** 1263 * This method refreshes the contents of the current row from the database. 1264 * 1265 * @exception SQLException If an error occurs. 1266 */ 1267 void refreshRow() throws SQLException; 1268 1269 /** 1270 * This method cancels any changes that have been made to a row. If 1271 * the <code>rowUpdate</code> method has been called, then the changes 1272 * cannot be undone. 1273 * 1274 * @exception SQLException If an error occurs. 1275 */ 1276 void cancelRowUpdates() throws SQLException; 1277 1278 /** 1279 * This method positions the result set to the "insert row", which allows 1280 * a new row to be inserted into the database from the result set. 1281 * 1282 * @exception SQLException If an error occurs. 1283 */ 1284 void moveToInsertRow() throws SQLException; 1285 1286 /** 1287 * This method moves the result set position from the insert row back to 1288 * the current row that was selected prior to moving to the insert row. 1289 * 1290 * @exception SQLException If an error occurs. 1291 */ 1292 void moveToCurrentRow() throws SQLException; 1293 1294 /** 1295 * This method returns a the <code>Statement</code> that was used to 1296 * produce this result set. 1297 * 1298 * @return The <code>Statement</code> used to produce this result set. 1299 * 1300 * @exception SQLException If an error occurs. 1301 */ 1302 Statement getStatement() throws SQLException; 1303 1304 /** 1305 * This method returns the value of the specified column as a Java 1306 * <code>Object</code> using the specified SQL type to Java type map. 1307 * 1308 * @param columnIndex The index of the column to return. 1309 * @param map The SQL type to Java type map to use. 1310 * @return The value of the column as an <code>Object</code>. 1311 * @exception SQLException If an error occurs. 1312 */ 1313 Object getObject(int columnIndex, Map<String, Class<?>> map) 1314 throws SQLException; 1315 1316 /** 1317 * This method returns a <code>Ref</code> for the specified column which 1318 * represents the structured type for the column. 1319 * 1320 * @param columnIndex The index of the column to return. 1321 * @return A <code>Ref</code> object for the column 1322 * @exception SQLException If an error occurs. 1323 */ 1324 Ref getRef(int columnIndex) throws SQLException; 1325 1326 /** 1327 * This method returns the specified column value as a BLOB. 1328 * 1329 * @param columnIndex The index of the column value to return. 1330 * @return The value of the column as a BLOB. 1331 * @exception SQLException If an error occurs. 1332 */ 1333 Blob getBlob(int columnIndex) throws SQLException; 1334 1335 /** 1336 * This method returns the specified column value as a CLOB. 1337 * 1338 * @param columnIndex The index of the column value to return. 1339 * @return The value of the column as a CLOB. 1340 * @exception SQLException If an error occurs. 1341 */ 1342 Clob getClob(int columnIndex) throws SQLException; 1343 1344 /** 1345 * This method returns the specified column value as an <code>Array</code>. 1346 * 1347 * @param columnIndex The index of the column value to return. 1348 * @return The value of the column as an <code>Array</code>. 1349 * @exception SQLException If an error occurs. 1350 */ 1351 Array getArray(int columnIndex) throws SQLException; 1352 1353 /** 1354 * This method returns the value of the specified column as a Java 1355 * <code>Object</code> using the specified SQL type to Java type map. 1356 * 1357 * @param columnName The name of the column to return. 1358 * @param map The SQL type to Java type map to use. 1359 * @return The value of the column as an <code>Object</code>. 1360 * @exception SQLException If an error occurs. 1361 */ 1362 Object getObject(String columnName, Map<String, Class<?>> map) 1363 throws SQLException; 1364 1365 /** 1366 * This method returns a <code>Ref</code> for the specified column which 1367 * represents the structured type for the column. 1368 * 1369 * @param columnName The name of the column to return. 1370 * @return A <code>Ref</code> object for the column 1371 * @exception SQLException If an error occurs. 1372 */ 1373 Ref getRef(String columnName) throws SQLException; 1374 1375 /** 1376 * This method returns the specified column value as a BLOB. 1377 * 1378 * @param columnName The name of the column value to return. 1379 * @return The value of the column as a BLOB. 1380 * @exception SQLException If an error occurs. 1381 */ 1382 Blob getBlob(String columnName) throws SQLException; 1383 1384 /** 1385 * This method returns the specified column value as a CLOB. 1386 * 1387 * @param columnName The name of the column value to return. 1388 * @return The value of the column as a CLOB. 1389 * @exception SQLException If an error occurs. 1390 */ 1391 Clob getClob(String columnName) throws SQLException; 1392 1393 /** 1394 * This method returns the specified column value as an <code>Array</code>. 1395 * 1396 * @param columnName The name of the column value to return. 1397 * @return The value of the column as an <code>Array</code>. 1398 * @exception SQLException If an error occurs. 1399 */ 1400 Array getArray(String columnName) throws SQLException; 1401 1402 /** 1403 * This method returns the specified column value as a 1404 * <code>java.sql.Date</code>. The specified <code>Calendar</code> is used 1405 * to generate a value for the date if the database does not support 1406 * timezones. 1407 * 1408 * @param columnIndex The index of the column value to return. 1409 * @param cal The <code>Calendar</code> to use for calculating timezones. 1410 * @return The value of the column as a <code>java.sql.Date</code>. 1411 * @exception SQLException If an error occurs. 1412 */ 1413 Date getDate(int columnIndex, Calendar cal) throws SQLException; 1414 1415 /** 1416 * This method returns the specified column value as a 1417 * <code>java.sql.Date</code>. The specified <code>Calendar</code> is used 1418 * to generate a value for the date if the database does not support 1419 * timezones. 1420 * 1421 * @param columnName The name of the column value to return. 1422 * @param cal The <code>Calendar</code> to use for calculating timezones. 1423 * @return The value of the column as a <code>java.sql.Date</code>. 1424 * @exception SQLException If an error occurs. 1425 */ 1426 Date getDate(String columnName, Calendar cal) throws SQLException; 1427 1428 /** 1429 * This method returns the specified column value as a 1430 * <code>java.sql.Time</code>. The specified <code>Calendar</code> is used 1431 * to generate a value for the time if the database does not support 1432 * timezones. 1433 * 1434 * @param columnIndex The index of the column value to return. 1435 * @param cal The <code>Calendar</code> to use for calculating timezones. 1436 * @return The value of the column as a <code>java.sql.Time</code>. 1437 * @exception SQLException If an error occurs. 1438 */ 1439 Time getTime(int columnIndex, Calendar cal) throws SQLException; 1440 1441 /** 1442 * This method returns the specified column value as a 1443 * <code>java.sql.Time</code>. The specified <code>Calendar</code> is used 1444 * to generate a value for the time if the database does not support 1445 * timezones. 1446 * 1447 * @param columnName The name of the column value to return. 1448 * @param cal The <code>Calendar</code> to use for calculating timezones. 1449 * @return The value of the column as a <code>java.sql.Time</code>. 1450 * @exception SQLException If an error occurs. 1451 */ 1452 Time getTime(String columnName, Calendar cal) throws SQLException; 1453 1454 /** 1455 * This method returns the specified column value as a 1456 * <code>java.sql.Timestamp</code>. The specified <code>Calendar</code> is used 1457 * to generate a value for the timestamp if the database does not support 1458 * timezones. 1459 * 1460 * @param columnIndex The index of the column value to return. 1461 * @param cal The <code>Calendar</code> to use for calculating timezones. 1462 * @return The value of the column as a <code>java.sql.Timestamp</code>. 1463 * @exception SQLException If an error occurs. 1464 */ 1465 Timestamp getTimestamp(int columnIndex, Calendar cal) 1466 throws SQLException; 1467 1468 /** 1469 * This method returns the specified column value as a 1470 * <code>java.sql.Timestamp</code>. The specified <code>Calendar</code> is used 1471 * to generate a value for the timestamp if the database does not support 1472 * timezones. 1473 * 1474 * @param columnName The name of the column value to return. 1475 * @param cal The <code>Calendar</code> to use for calculating timezones. 1476 * 1477 * @return The value of the column as a <code>java.sql.Timestamp</code>. 1478 * 1479 * @exception SQLException If an error occurs. 1480 */ 1481 Timestamp getTimestamp(String columnName, Calendar cal) 1482 throws SQLException; 1483 1484 /** 1485 * This method returns the specified column value as a 1486 * <code>java.net.URL</code>. 1487 * 1488 * @param columnIndex The index of the column value to return. 1489 * @exception SQLException If an error occurs. 1490 * @since 1.4 1491 */ 1492 URL getURL(int columnIndex) throws SQLException; 1493 1494 /** 1495 * This method returns the specified column value as a 1496 * <code>java.net.URL</code>. 1497 * 1498 * @param columnName The name of the column value to return. 1499 * @exception SQLException If an error occurs. 1500 * @since 1.4 1501 */ 1502 URL getURL(String columnName) throws SQLException; 1503 1504 /** 1505 * This method updates the specified column to have a 1506 * <code>java.sql.Ref</code> value. 1507 * This does not update the actual database. <code>updateRow</code> must be 1508 * called in order to do that. 1509 * 1510 * @parm columnIndex The index of the column value to update. 1511 * @parm value The <code>java.sql.Ref</code> used to set the new value 1512 * of the column. 1513 * @exception SQLException If an error occurs. 1514 * @since 1.4 1515 */ 1516 void updateRef(int columnIndex, Ref value) throws SQLException; 1517 1518 /** 1519 * This method updates the specified column to have a 1520 * <code>java.sql.Ref</code> value. 1521 * This does not update the actual database. <code>updateRow</code> must be 1522 * called in order to do that. 1523 * 1524 * @parm columnName The name of the column value to update. 1525 * @parm value The <code>java.sql.Ref</code> used to set the new value 1526 * of the column. 1527 * @exception SQLException If an error occurs. 1528 * @since 1.4 1529 */ 1530 void updateRef(String columnName, Ref value) throws SQLException; 1531 1532 /** 1533 * This method updates the specified column to have a 1534 * <code>java.sql.Blob</code> value. 1535 * This does not update the actual database. <code>updateRow</code> must be 1536 * called in order to do that. 1537 * 1538 * @parm columnIndex The index of the column value to update. 1539 * @parm value The <code>java.sql.Blob</code> used to set the new value 1540 * of the column. 1541 * @exception SQLException If an error occurs. 1542 * @since 1.4 1543 */ 1544 void updateBlob(int columnIndex, Blob value) throws SQLException; 1545 1546 /** 1547 * This method updates the specified column to have a 1548 * <code>java.sql.Blob</code> value. 1549 * This does not update the actual database. <code>updateRow</code> must be 1550 * called in order to do that. 1551 * 1552 * @parm columnName The name of the column value to update. 1553 * @parm value The <code>java.sql.Blob</code> used to set the new value 1554 * of the column. 1555 * @exception SQLException If an error occurs. 1556 * @since 1.4 1557 */ 1558 void updateBlob(String columnName, Blob value) throws SQLException; 1559 1560 /** 1561 * This method updates the specified column to have a 1562 * <code>java.sql.Clob</code> value. 1563 * This does not update the actual database. <code>updateRow</code> must be 1564 * called in order to do that. 1565 * 1566 * @parm columnIndex The index of the column value to update. 1567 * @parm value The <code>java.sql.Clob</code> used to set the new value 1568 * of the column. 1569 * @exception SQLException If an error occurs. 1570 * @since 1.4 1571 */ 1572 void updateClob(int columnIndex, Clob value) throws SQLException; 1573 1574 /** 1575 * This method updates the specified column to have a 1576 * <code>java.sql.Clob</code> value. 1577 * This does not update the actual database. <code>updateRow</code> must be 1578 * called in order to do that. 1579 * 1580 * @parm columnName The name of the column value to update. 1581 * @parm value The <code>java.sql.Clob</code> used to set the new value 1582 * of the column. 1583 * @exception SQLException If an error occurs. 1584 * @since 1.4 1585 */ 1586 void updateClob(String columnName, Clob value) throws SQLException; 1587 1588 /** 1589 * This method updates the specified column to have a 1590 * <code>java.sqlArray</code> value. 1591 * This does not update the actual database. <code>updateRow</code> must be 1592 * called in order to do that. 1593 * 1594 * @parm columnIndex The index of the column value to update. 1595 * @parm value The new value of the column. 1596 * @exception SQLException If an error occurs. 1597 * @since 1.4 1598 */ 1599 void updateArray(int columnIndex, Array value) throws SQLException; 1600 1601 /** 1602 * This method updates the specified column to have a 1603 * <code>java.sqlArray</code> value. 1604 * This does not update the actual database. <code>updateRow</code> must be 1605 * called in order to do that. 1606 * 1607 * @parm columnName The name of the column value to update. 1608 * @parm value The new value of the column. 1609 * @exception SQLException If an error occurs. 1610 * @since 1.4 1611 */ 1612 void updateArray(String columnName, Array value) throws SQLException; 1613}