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