1/* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18package java.sql; 19 20import java.io.InputStream; 21import java.io.Reader; 22import java.math.BigDecimal; 23import java.net.URL; 24import java.util.Calendar; 25import java.util.Map; 26 27/** 28 * An interface for an object which represents a database table entry, returned 29 * as the result of the query to the database. 30 * <p> 31 * {@code ResultSet}s have a cursor which points to the current data table row. 32 * When the {@code ResultSet} is created, the cursor's location is one position 33 * ahead of the first row. To move the cursor to the first and consecutive rows, 34 * use the {@code next} method. The {@code next} method returns {@code true} as 35 * long as there are more rows in the {@code ResultSet}, otherwise it returns 36 * {@code false}. 37 * <p> 38 * The default type of {@code ResultSet} can not be updated and its cursor can 39 * only advance forward through the rows of data. This means that it is only 40 * possible to read through it once. However, other kinds of {@code ResultSet} 41 * are implemented: an <i>updatable</i> type and also types where the cursor can 42 * be <i>scrolled</i> forward and backward through the rows of data. How such a 43 * {@code ResultSet} is created is demonstrated in the following example: 44 * <ul> 45 * <dd> 46 * {@code Connection con;}</dd> 47 * <dd>{@code Statement aStatement = con.createStatement( 48 * ResultSet.TYPE_SCROLL_SENSITIVE,}{@code ResultSet.CONCUR_UPDATABLE );}</dd> 49 * <dd>{@code ResultSet theResultSet = 50 * theStatement.executeQuery("SELECT price, quantity FROM STOCKTABLE");}</dd> 51 * <dd>{@code // theResultSet is both scrollable and updatable}</dd> </ul> 52 * <p> 53 * The {@code ResultSet} interface provides a series of methods for retrieving 54 * data from columns in the current row, such as {@code getDate} and {@code 55 * getFloat}. The columns are retrieved either by their index number (starting 56 * at 1) or by their name - there are separate methods for both techniques of 57 * column addressing. The column names are case insensitive. If several columns 58 * have the same name, then the getter methods use the first matching column. 59 * This means that if column names are used, it is not possible to guarantee 60 * that the name will retrieve data from the intended column - for certainty it 61 * is better to use column indexes. Ideally the columns should be read 62 * left-to-right and read once only, since not all databases are optimized to 63 * handle other techniques of reading the data. 64 * <p> 65 * When reading data via the appropriate getter methods, the JDBC driver maps 66 * the SQL data retrieved from the database to the Java type implied by the 67 * method invoked by the application. The JDBC specification has a table for the 68 * mappings from SQL types to Java types. 69 * <p> 70 * There are also methods for writing data into the {@code ResultSet}, such as 71 * {@code updateInt} and {@code updateString}. The update methods can be used 72 * either to modify the data of an existing row or to insert new data rows into 73 * the {@code ResultSet} . Modification of existing data involves moving the 74 * cursor to the row which needs modification and then using the update methods 75 * to modify the data, followed by calling the {@code ResultSet.updateRow} 76 * method. For insertion of new rows, the cursor is first moved to a special row 77 * called the <i>Insert Row</i>, data is added using the update methods, 78 * followed by calling the {@code ResultSet.insertRow} method. 79 * <p> 80 * A {@code ResultSet} is closed if the statement which generated it closes, the 81 * statement is executed again, or the same statement's next {@code ResultSet} 82 * is retrieved (if the statement returned of multiple results). 83 */ 84public interface ResultSet extends Wrapper, AutoCloseable { 85 86 /** 87 * A constant used to indicate that a {@code ResultSet} object must be 88 * closed when the method {@code Connection.commit} is invoked. 89 */ 90 public static final int CLOSE_CURSORS_AT_COMMIT = 2; 91 92 /** 93 * A constant used to indicate that a {@code ResultSet} object must not be 94 * closed when the method {@code Connection.commit} is invoked. 95 */ 96 public static final int HOLD_CURSORS_OVER_COMMIT = 1; 97 98 /** 99 * A constant used to indicate the concurrency mode for a {@code ResultSet} 100 * object that cannot be updated. 101 */ 102 public static final int CONCUR_READ_ONLY = 1007; 103 104 /** 105 * A constant used to indicate the concurrency mode for a {@code ResultSet} 106 * object that can be updated. 107 */ 108 public static final int CONCUR_UPDATABLE = 1008; 109 110 /** 111 * A constant used to indicate processing of the rows of a {@code ResultSet} 112 * in the forward direction, first to last. 113 */ 114 public static final int FETCH_FORWARD = 1000; 115 116 /** 117 * A constant used to indicate processing of the rows of a {@code ResultSet} 118 * in the reverse direction, last to first. 119 */ 120 public static final int FETCH_REVERSE = 1001; 121 122 /** 123 * A constant used to indicate that the order of processing of the rows of a 124 * {@code ResultSet} is unknown. 125 */ 126 public static final int FETCH_UNKNOWN = 1002; 127 128 /** 129 * A constant used to indicate a {@code ResultSet} object whose cursor can 130 * only move forward. 131 */ 132 public static final int TYPE_FORWARD_ONLY = 1003; 133 134 /** 135 * A constant used to indicate a {@code ResultSet} object which is 136 * scrollable but is insensitive to changes made by others. 137 */ 138 public static final int TYPE_SCROLL_INSENSITIVE = 1004; 139 140 /** 141 * A constant used to indicate a {@code ResultSet} object which is 142 * scrollable and sensitive to changes made by others. 143 */ 144 public static final int TYPE_SCROLL_SENSITIVE = 1005; 145 146 /** 147 * Moves the cursor to a specified row number in the {@code ResultSet}. 148 * 149 * @param row 150 * the index of the row starting at index 1. Index {@code -1} 151 * returns the last row. 152 * @return {@code true} if the new cursor position is on the {@code 153 * ResultSet}, {@code false} otherwise. 154 * @throws SQLException 155 * if a database error happens. 156 */ 157 public boolean absolute(int row) throws SQLException; 158 159 /** 160 * Moves the cursor to the end of the {@code ResultSet}, after the last row. 161 * 162 * @throws SQLException 163 * if a database error happens. 164 */ 165 public void afterLast() throws SQLException; 166 167 /** 168 * Moves the cursor to the start of the {@code ResultSet}, before the first 169 * row. 170 * 171 * @throws SQLException 172 * if a database error happens. 173 */ 174 public void beforeFirst() throws SQLException; 175 176 /** 177 * Cancels any updates made to the current row in the {@code ResultSet}. 178 * 179 * @throws SQLException 180 * if a database error happens. 181 */ 182 public void cancelRowUpdates() throws SQLException; 183 184 /** 185 * Clears all warnings related to this {@code ResultSet}. 186 * 187 * @throws SQLException 188 * if a database error happens. 189 */ 190 public void clearWarnings() throws SQLException; 191 192 /** 193 * Releases this {@code ResultSet}'s database and JDBC resources. You are 194 * strongly advised to use this method rather than relying on the release 195 * being done when the {@code ResultSet}'s finalize method is called during 196 * garbage collection process. Note that the {@code close()} method might 197 * take some time to complete since it is dependent on the behavior of the 198 * connection to the database and the database itself. 199 * 200 * @throws SQLException 201 * if a database error happens. 202 */ 203 public void close() throws SQLException; 204 205 /** 206 * Deletes the current row from the {@code ResultSet} and from the 207 * underlying database. 208 * 209 * @throws SQLException 210 * if a database error happens. 211 */ 212 public void deleteRow() throws SQLException; 213 214 /** 215 * Gets the index number for a column in the {@code ResultSet} from the 216 * provided column name. 217 * 218 * @param columnName 219 * the column name. 220 * @return the column's index in the {@code ResultSet} identified by column 221 * name. 222 * @throws SQLException 223 * if a database error happens. 224 */ 225 public int findColumn(String columnName) throws SQLException; 226 227 /** 228 * Shifts the cursor position to the first row in the {@code ResultSet}. 229 * 230 * @return {@code true} if the position is in a legitimate row, {@code 231 * false} if the {@code ResultSet} contains no rows. 232 * @throws SQLException 233 * if a database error happens. 234 */ 235 public boolean first() throws SQLException; 236 237 /** 238 * Gets the content of a column specified by column index in the current row 239 * of this {@code ResultSet} as a {@code java.sql.Array}. 240 * 241 * @param columnIndex 242 * the index of the column to read 243 * @return a {@code java.sql.Array} with the data from the column. 244 * @throws SQLException 245 * if a database error happens. 246 */ 247 public Array getArray(int columnIndex) throws SQLException; 248 249 /** 250 * Gets the value of a column specified by column name as a {@code 251 * java.sql.Array}. 252 * 253 * @param colName 254 * the name of the column to read. 255 * @return a {@code java.sql.Array} with the data from the specified column. 256 * @throws SQLException 257 * if a database error happens. 258 */ 259 public Array getArray(String colName) throws SQLException; 260 261 /** 262 * Gets the value of a column specified by column index as an ASCII 263 * character stream. 264 * 265 * @param columnIndex 266 * the index of the column to read. 267 * @return an {@code InputStream} with the data from the column. 268 * @throws SQLException 269 * if a database error happens. 270 */ 271 public InputStream getAsciiStream(int columnIndex) throws SQLException; 272 273 /** 274 * Gets the value of a column specified by column name as an ASCII character 275 * stream. 276 * 277 * @param columnName 278 * the name of the column to read 279 * @return an {@code InputStream} with the data from the column. 280 * @throws SQLException 281 * if a database error happens. 282 */ 283 public InputStream getAsciiStream(String columnName) throws SQLException; 284 285 /** 286 * Gets the value of a column specified by column index as a {@code 287 * java.math.BigDecimal}. 288 * 289 * @param columnIndex 290 * the index of the column to read. 291 * @return a {@code BigDecimal} with the value of the column. 292 * @throws SQLException 293 * if a database error happens. 294 */ 295 public BigDecimal getBigDecimal(int columnIndex) throws SQLException; 296 297 /** 298 * Gets the value of a column specified by column index as a {@code 299 * java.math.BigDecimal}. 300 * 301 * @deprecated Use {@link #getBigDecimal(int)} or {@link #getBigDecimal(String)} instead. 302 * @param columnIndex 303 * the index of the column to read. 304 * @param scale 305 * the number of digits after the decimal point 306 * @return a {@code BigDecimal} with the value of the column. 307 * @throws SQLException 308 * if a database error happens. 309 */ 310 @Deprecated 311 public BigDecimal getBigDecimal(int columnIndex, int scale) 312 throws SQLException; 313 314 /** 315 * Gets the value of a column specified by column name, as a {@code 316 * java.math.BigDecimal}. 317 * 318 * @param columnName 319 * the name of the column to read. 320 * @return a BigDecimal with value of the column. 321 * @throws SQLException 322 * if a database error happens. 323 */ 324 public BigDecimal getBigDecimal(String columnName) throws SQLException; 325 326 /** 327 * Gets the value of a column specified by column name, as a {@code 328 * java.math.BigDecimal}. 329 * 330 * @deprecated Use {@link #getBigDecimal(int)} or {@link #getBigDecimal(String)} instead. 331 * @param columnName 332 * the name of the column to read. 333 * @param scale 334 * the number of digits after the decimal point 335 * @return a BigDecimal with value of the column. 336 * @throws SQLException 337 * if a database error happens. 338 */ 339 @Deprecated 340 public BigDecimal getBigDecimal(String columnName, int scale) 341 throws SQLException; 342 343 /** 344 * Gets the value of a column specified by column index as a binary 345 * stream. 346 * <p> 347 * This method can be used to read {@code LONGVARBINARY} values. All of the 348 * data in the {@code InputStream} should be read before getting data from 349 * any other column. A further call to a getter method will implicitly close 350 * the {@code InputStream}. 351 * 352 * @param columnIndex 353 * the index of the column to read. 354 * @return an {@code InputStream} with the data from the column. If the 355 * column value is SQL {@code NULL}, {@code null} is returned. 356 * @throws SQLException 357 * if a database error happens. 358 */ 359 public InputStream getBinaryStream(int columnIndex) throws SQLException; 360 361 /** 362 * Gets the value of a column specified by column name as a binary stream. 363 * <p> 364 * This method can be used to read {@code LONGVARBINARY} values. All of the 365 * data in the {@code InputStream} should be read before getting data from 366 * any other column. A further call to a getter method will implicitly close 367 * the {@code InputStream}. 368 * 369 * @param columnName 370 * the name of the column to read. 371 * @return an {@code InputStream} with the data from the column if the 372 * column value is SQL {@code NULL}, {@code null} is returned. 373 * @throws SQLException 374 * if a database error happens. 375 */ 376 public InputStream getBinaryStream(String columnName) throws SQLException; 377 378 /** 379 * Gets the value of a column specified by column index as a {@code 380 * java.sql.Blob} object. 381 * 382 * @param columnIndex 383 * the index of the column to read. 384 * @return a {@code java.sql.Blob} with the value of the column. 385 * @throws SQLException 386 * if a database error happens. 387 */ 388 public Blob getBlob(int columnIndex) throws SQLException; 389 390 /** 391 * Gets the value of a column specified by column name, as a {@code 392 * java.sql.Blob} object. 393 * 394 * @param columnName 395 * the name of the column to read. 396 * @return a {@code java.sql.Blob} with the value of the column. 397 * @throws SQLException 398 * if a database error happens. 399 */ 400 public Blob getBlob(String columnName) throws SQLException; 401 402 /** 403 * Gets the value of a column specified by column index as a {@code boolean} 404 * . 405 * 406 * @param columnIndex 407 * the index of the column to read. 408 * @return a {@code boolean} value from the column. If the column is SQL 409 * {@code NULL}, {@code false} is returned. 410 * @throws SQLException 411 * if a database error happens. 412 */ 413 public boolean getBoolean(int columnIndex) throws SQLException; 414 415 /** 416 * Gets the value of a column specified by column name, as a {@code boolean} 417 * . 418 * 419 * @param columnName 420 * the name of the column to read. 421 * @return a {@code boolean} value from the column. If the column is SQL 422 * {@code NULL}, {@code false} is returned. 423 * @throws SQLException 424 * if a database error happens. 425 */ 426 public boolean getBoolean(String columnName) throws SQLException; 427 428 /** 429 * Gets the value of a column specified by column index as a {@code byte}. 430 * 431 * @param columnIndex 432 * the index of the column to read. 433 * @return a {@code byte} equal to the value of the column. 0 if the value 434 * is SQL {@code NULL}. 435 * @throws SQLException 436 * if a database error happens. 437 */ 438 public byte getByte(int columnIndex) throws SQLException; 439 440 /** 441 * Gets the value of a column specified by column name as a {@code byte}. 442 * 443 * @param columnName 444 * the name of the column to read. 445 * @return a {@code byte} equal to the value of the column. 0 if the value 446 * is SQL {@code NULL}. 447 * @throws SQLException 448 * if a database error happens. 449 */ 450 public byte getByte(String columnName) throws SQLException; 451 452 /** 453 * Gets the value of a column specified by column index as a byte array. 454 * 455 * @param columnIndex 456 * the index of the column to read. 457 * @return a byte array containing the value of the column. {@code null} if 458 * the column contains SQL {@code NULL}. 459 * @throws SQLException 460 * if a database error happens. 461 */ 462 public byte[] getBytes(int columnIndex) throws SQLException; 463 464 /** 465 * Gets the value of a column specified by column name as a byte array. 466 * 467 * @param columnName 468 * the name of the column to read. 469 * @return a byte array containing the value of the column. {@code null} if 470 * the column contains SQL {@code NULL}. 471 * @throws SQLException 472 * if a database error happens. 473 */ 474 public byte[] getBytes(String columnName) throws SQLException; 475 476 /** 477 * Gets the value of a column specified by column index as a {@code 478 * java.io.Reader} object. 479 * 480 * @param columnIndex 481 * the index of the column to read. 482 * @return a {@code Reader} holding the value of the column. {@code null} if 483 * the column value is SQL {@code NULL}. 484 * @throws SQLException 485 * if a database error happens. 486 * @see java.io.Reader 487 */ 488 public Reader getCharacterStream(int columnIndex) throws SQLException; 489 490 /** 491 * Gets the value of a column specified by column name as a {@code 492 * java.io.Reader} object. 493 * 494 * @param columnName 495 * the name of the column to read. 496 * @return a {@code Reader} holding the value of the column. {@code null} if 497 * the column value is SQL {@code NULL}. 498 * @throws SQLException 499 * if a database error happens. 500 */ 501 public Reader getCharacterStream(String columnName) throws SQLException; 502 503 /** 504 * Gets the value of a column specified by column index as a {@code 505 * java.sql.Clob}. 506 * 507 * @param columnIndex 508 * the index of the column to read. 509 * @return a {@code Clob} object representing the value in the column. 510 * {@code null} if the value is SQL {@code NULL}. 511 * @throws SQLException 512 * if a database error happens. 513 */ 514 public Clob getClob(int columnIndex) throws SQLException; 515 516 /** 517 * Gets the value of a column specified by column name as a {@code 518 * java.sql.Clob}. 519 * 520 * @param colName 521 * the name of the column to read. 522 * @return a {@code Clob} object representing the value in the column. 523 * {@code null} if the value is SQL {@code NULL}. 524 * @throws SQLException 525 * if a database error happens. 526 */ 527 public Clob getClob(String colName) throws SQLException; 528 529 /** 530 * Gets the concurrency mode of this {@code ResultSet}. 531 * 532 * @return the concurrency mode - one of: {@code ResultSet.CONCUR_READ_ONLY} 533 * , {@code ResultSet.CONCUR_UPDATABLE}. 534 * @throws SQLException 535 * if a database error happens. 536 */ 537 public int getConcurrency() throws SQLException; 538 539 /** 540 * Gets the name of the SQL cursor of this {@code ResultSet}. 541 * 542 * @return the SQL cursor name. 543 * @throws SQLException 544 * if a database error happens. 545 */ 546 public String getCursorName() throws SQLException; 547 548 /** 549 * Gets the value of a column specified by column index as a {@code 550 * java.sql.Date}. 551 * 552 * @param columnIndex 553 * the index of the column to read. 554 * @return a {@code java.sql.Date} matching the column value. {@code null} 555 * if the column is SQL {@code NULL}. 556 * @throws SQLException 557 * if a database error happens. 558 */ 559 public Date getDate(int columnIndex) throws SQLException; 560 561 /** 562 * Gets the value of a column specified by column index as a {@code 563 * java.sql.Date}. This method uses a supplied calendar to compute the Date. 564 * 565 * @param columnIndex 566 * the index of the column to read. 567 * @param cal 568 * a {@code java.util.Calendar} to use in constructing the Date. 569 * @return a {@code java.sql.Date} matching the column value. {@code null} 570 * if the column is SQL {@code NULL}. 571 * @throws SQLException 572 * if a database error happens. 573 */ 574 public Date getDate(int columnIndex, Calendar cal) throws SQLException; 575 576 /** 577 * Gets the value of a column specified by column name as a {@code 578 * java.sql.Date}. 579 * 580 * @param columnName 581 * the name of the column to read. 582 * @return a {@code java.sql.Date} matching the column value. {@code null} 583 * if the column is SQL {@code NULL}. 584 * @throws SQLException 585 * if a database error happens. 586 */ 587 public Date getDate(String columnName) throws SQLException; 588 589 /** 590 * Gets the value of a column specified by column name, as a {@code 591 * java.sql.Date} object. 592 * 593 * @param columnName 594 * the name of the column to read. 595 * @param cal 596 * {@code java.util.Calendar} to use in constructing the Date. 597 * @return a {@code java.sql.Date} matching the column value. {@code null} 598 * if the column is SQL {@code NULL}. 599 * @throws SQLException 600 * if a database error happens. 601 */ 602 public Date getDate(String columnName, Calendar cal) throws SQLException; 603 604 /** 605 * Gets the value of a column specified by column index as a {@code double} 606 * value. 607 * 608 * @param columnIndex 609 * the index of the column to read. 610 * @return a {@code double} equal to the column value. {@code 0.0} if the 611 * column is SQL {@code NULL}. 612 * @throws SQLException 613 * if a database error happens. 614 */ 615 public double getDouble(int columnIndex) throws SQLException; 616 617 /** 618 * Gets the value of a column specified by column name as a {@code double} 619 * value. 620 * 621 * @param columnName 622 * the name of the column to read. 623 * @return a {@code double} equal to the column value. {@code 0.0} if the 624 * column is SQL {@code NULL}. 625 * @throws SQLException 626 * if a database error happens. 627 */ 628 public double getDouble(String columnName) throws SQLException; 629 630 /** 631 * Gets the direction in which rows are fetched for this {@code ResultSet} 632 * object. 633 * 634 * @return the fetch direction. Will be one of: 635 * <ul> 636 * <li>ResultSet.FETCH_FORWARD</li><li>ResultSet.FETCH_REVERSE</li> 637 * <li>ResultSet.FETCH_UNKNOWN</li> 638 * </ul> 639 * @throws SQLException 640 * if a database error happens. 641 */ 642 public int getFetchDirection() throws SQLException; 643 644 /** 645 * Gets the fetch size (in number of rows) for this {@code ResultSet}. 646 * 647 * @return the fetch size as an int 648 * @throws SQLException 649 * if a database error happens. 650 */ 651 public int getFetchSize() throws SQLException; 652 653 /** 654 * Gets the value of a column specified by column index as a {@code float} 655 * value. 656 * 657 * @param columnIndex 658 * the index of the column to read. 659 * @return a {@code float} equal to the column value. {@code 0.0} if the 660 * column is SQL {@code NULL}. 661 * @throws SQLException 662 * if a database error happens. 663 */ 664 public float getFloat(int columnIndex) throws SQLException; 665 666 /** 667 * Gets the value of a column specified by column name as a {@code float} 668 * value. 669 * 670 * @param columnName 671 * the name of the column to read. 672 * @return a {@code float} equal to the column value. {@code 0.0} if the 673 * column is SQL {@code NULL}. 674 * @throws SQLException 675 * if a database error happens. 676 */ 677 public float getFloat(String columnName) throws SQLException; 678 679 /** 680 * Gets the value of a column specified by column index as an {@code int} 681 * value. 682 * 683 * @param columnIndex 684 * the index of the column to read. 685 * @return an {@code int} equal to the column value. {@code 0} if the 686 * column is SQL {@code NULL}. 687 * @throws SQLException 688 * if a database error happens. 689 */ 690 public int getInt(int columnIndex) throws SQLException; 691 692 /** 693 * Gets the value of a column specified by column name, as an {@code int} 694 * value. 695 * 696 * @param columnName 697 * the name of the column to read. 698 * @return an {@code int} equal to the column value. {@code 0} if the 699 * column is SQL {@code NULL}. 700 * @throws SQLException 701 * if a database error happens. 702 */ 703 public int getInt(String columnName) throws SQLException; 704 705 /** 706 * Gets the value of a column specified by column index as a {@code long} 707 * value. 708 * 709 * @param columnIndex 710 * the index of the column to read. 711 * @return a {@code long} equal to the column value. {@code 0} if the 712 * column is SQL {@code NULL}. 713 * @throws SQLException 714 * if a database error happens. 715 */ 716 public long getLong(int columnIndex) throws SQLException; 717 718 /** 719 * Gets the value of a column specified by column name, as a {@code long} 720 * value. 721 * 722 * @param columnName 723 * the name of the column to read. 724 * @return a {@code long} equal to the column value. {@code 0} if the 725 * column is SQL {@code NULL}. 726 * @throws SQLException 727 * if a database error happens. 728 */ 729 public long getLong(String columnName) throws SQLException; 730 731 /** 732 * Gets the metadata for this {@code ResultSet}. This defines the number, 733 * types and properties of the columns in the {@code ResultSet}. 734 * 735 * @return a {@code ResultSetMetaData} object with information about this 736 * {@code ResultSet}. 737 * @throws SQLException 738 * if a database error happens. 739 */ 740 public ResultSetMetaData getMetaData() throws SQLException; 741 742 /** 743 * Gets the value of a specified column as a Java {@code Object}. The type 744 * of the returned object will be the default according to the column's SQL 745 * type, following the JDBC specification for built-in types. 746 * <p> 747 * For SQL User Defined Types, if a column value is Structured or Distinct, 748 * this method behaves the same as a call to: {@code 749 * getObject(columnIndex,this.getStatement().getConnection().getTypeMap())} 750 * 751 * @param columnIndex 752 * the index of the column to read. 753 * @return an {@code Object} containing the value of the column. {@code 754 * null} if the column value is SQL {@code NULL}. 755 * @throws SQLException 756 * if a database error happens. 757 */ 758 public Object getObject(int columnIndex) throws SQLException; 759 760 /** 761 * Gets the value of a column specified by column index as a Java {@code 762 * Object}. 763 * <p> 764 * The type of the Java object will be determined by the supplied Map to 765 * perform the mapping of SQL {@code Struct} or Distinct types into Java 766 * objects. 767 * 768 * @param columnIndex 769 * the index of the column to read. 770 * @param map 771 * a {@code java.util.Map} containing a mapping from SQL Type 772 * names to Java classes. 773 * @return an {@code Object} containing the value of the column. {@code 774 * null} if the column value is SQL {@code NULL}. 775 * @throws SQLException 776 * if a database error happens. 777 */ 778 public Object getObject(int columnIndex, Map<String, Class<?>> map) 779 throws SQLException; 780 781 /** 782 * Gets the value of a specified column as a Java {@code Object}. The type 783 * of the returned object will be the default according to the column's SQL 784 * type, following the JDBC specification for built-in types. 785 * <p> 786 * For SQL User Defined Types, if a column value is structured or distinct, 787 * this method behaves the same as a call to: {@code 788 * getObject(columnIndex,this.getStatement().getConnection().getTypeMap())} 789 * 790 * @param columnName 791 * the name of the column to read. 792 * @return an {@code Object} containing the value of the column. {@code 793 * null} if the column value is SQL {@code NULL}. 794 * @throws SQLException 795 * if a database error happens. 796 */ 797 public Object getObject(String columnName) throws SQLException; 798 799 /** 800 * Gets the value of a column specified by column name as a Java {@code 801 * Object}. 802 * <p> 803 * The type of the Java object will be determined by the supplied Map to 804 * perform the mapping of SQL Struct or Distinct types into Java objects. 805 * 806 * @param columnName 807 * the name of the column to read. 808 * @param map 809 * a {@code java.util.Map} containing a mapping from SQL Type names to 810 * Java classes. 811 * @return an {@code Object} containing the value of the column. {@code 812 * null} if the column value is SQL {@code NULL}. 813 * @throws SQLException 814 * if a database error happens. 815 */ 816 public Object getObject(String columnName, Map<String, Class<?>> map) 817 throws SQLException; 818 819 /** 820 * Gets the value of a column specified by column index as a Java {@code 821 * java.sql.Ref}. 822 * 823 * @param columnIndex 824 * the index of the column to read. 825 * @return a Ref representing the value of the SQL REF in the column 826 * @throws SQLException 827 * if a database error happens. 828 */ 829 public Ref getRef(int columnIndex) throws SQLException; 830 831 /** 832 * Gets the value of a column specified by column name as a Java {@code 833 * java.sql.Ref}. 834 * 835 * @param colName 836 * the name of the column to read. 837 * @return a Ref representing the value of the SQL {@code REF} in the column 838 * @throws SQLException 839 * if a database error happens. 840 */ 841 public Ref getRef(String colName) throws SQLException; 842 843 /** 844 * Gets the number of the current row in the {@code ResultSet}. Row numbers 845 * start at 1 for the first row. 846 * 847 * @return the index number of the current row. {@code 0} is returned if 848 * there is no current row. 849 * @throws SQLException 850 * if a database error happens. 851 */ 852 public int getRow() throws SQLException; 853 854 /** 855 * Gets the value of a column specified by column index as a short value. 856 * 857 * @param columnIndex 858 * the index of the column to read. 859 * @return a short value equal to the value of the column. {@code 0} if 860 * the value is SQL {@code NULL}. 861 * @throws SQLException 862 * if a database error happens. 863 */ 864 public short getShort(int columnIndex) throws SQLException; 865 866 /** 867 * Gets the value of a column specified by column name, as a short value. 868 * 869 * @param columnName 870 * the name of the column to read. 871 * @return a short value equal to the value of the column. {@code 0} if 872 * the value is SQL {@code NULL}. 873 * @throws SQLException 874 * if a database error happens. 875 */ 876 public short getShort(String columnName) throws SQLException; 877 878 /** 879 * Gets the statement that produced this {@code ResultSet}. If the {@code 880 * ResultSet} was not created by a statement (i.e. because it was returned 881 * from one of the {@link DatabaseMetaData} methods), {@code null} is 882 * returned. 883 * 884 * @return the Statement which produced this {@code ResultSet}, or {@code 885 * null} if the {@code ResultSet} was not created by a Statement. 886 * @throws SQLException 887 * if a database error happens. 888 */ 889 public Statement getStatement() throws SQLException; 890 891 /** 892 * Gets the value of a column specified by column index as a String. 893 * 894 * @param columnIndex 895 * the index of the column to read. 896 * @return the String representing the value of the column, {@code null} if 897 * the column is SQL {@code NULL}. 898 * @throws SQLException 899 * if a database error happens. 900 */ 901 public String getString(int columnIndex) throws SQLException; 902 903 /** 904 * Gets the value of a column specified by column name, as a String. 905 * 906 * @param columnName 907 * the name of the column to read. 908 * @return the String representing the value of the column, {@code null} if 909 * the column is SQL {@code NULL}. 910 * @throws SQLException 911 * if a database error happens. 912 */ 913 public String getString(String columnName) throws SQLException; 914 915 /** 916 * Gets the value of a column specified by column index as a {@code 917 * java.sql.Time} value. 918 * 919 * @param columnIndex 920 * the index of the column to read. 921 * @return a Time representing the column value, {@code null} if the column 922 * value is SQL {@code NULL}. 923 * @throws SQLException 924 * if a database error happens. 925 */ 926 public Time getTime(int columnIndex) throws SQLException; 927 928 /** 929 * Gets the value of a column specified by column index as a {@code 930 * java.sql.Time} value. The supplied {@code Calendar} is used to 931 * map the SQL {@code Time} value to a Java Time value. 932 * 933 * @param columnIndex 934 * the index of the column to read. 935 * @param cal 936 * a {@code Calendar} to use in creating the Java Time value. 937 * @return a Time representing the column value, {@code null} if the column 938 * value is SQL {@code NULL}. 939 * @throws SQLException 940 * if a database error happens. 941 */ 942 public Time getTime(int columnIndex, Calendar cal) throws SQLException; 943 944 /** 945 * Gets the value of a column specified by column name, as a {@code 946 * java.sql.Time} value. 947 * 948 * @param columnName 949 * the name of the column to read. 950 * @return the column value, {@code null} if the column value is SQL {@code 951 * NULL}. 952 * @throws SQLException 953 * if a database error happens. 954 */ 955 public Time getTime(String columnName) throws SQLException; 956 957 /** 958 * Gets the value of a column specified by column index, as a {@code 959 * java.sql.Time} value. The supplied {@code Calendar} is used to 960 * map the SQL {@code Time} value to a Java Time value. 961 * 962 * @param columnName 963 * the name of the column to read. 964 * @param cal 965 * a {@code Calendar} to use in creating the Java time value. 966 * @return a Time representing the column value, {@code null} if the column 967 * value is SQL {@code NULL}. 968 * @throws SQLException 969 * if a database error happens. 970 */ 971 public Time getTime(String columnName, Calendar cal) throws SQLException; 972 973 /** 974 * Gets the value of a column specified by column index as a {@code 975 * java.sql.Timestamp} value. 976 * 977 * @param columnIndex 978 * the index of the column to read. 979 * @return a timestamp representing the column value, {@code null} if the 980 * column value is SQL {@code NULL}. 981 * @throws SQLException 982 * if a database error happens. 983 */ 984 public Timestamp getTimestamp(int columnIndex) throws SQLException; 985 986 /** 987 * Gets the value of a column specified by column index, as a {@code 988 * java.sql.Timestamp} value. The supplied Calendar is used when mapping 989 * the SQL {@code Timestamp} value to a Java {@code Timestamp} value. 990 * 991 * @param columnIndex 992 * the index of the column to read. 993 * @param cal 994 * Calendar to use in creating the Java timestamp value. 995 * @return a timestamp representing the column value, {@code null} if the 996 * column value is SQL NULL. 997 * @throws SQLException 998 * if a database error happens. 999 */ 1000 public Timestamp getTimestamp(int columnIndex, Calendar cal) 1001 throws SQLException; 1002 1003 /** 1004 * Gets the value of a column specified by column name, as a {@code 1005 * java.sql.Timestamp} value. 1006 * 1007 * @param columnName 1008 * the name of the column to read. 1009 * @return a timestamp representing the column value, {@code null} if the 1010 * column value is SQL {@code NULL}. 1011 * @throws SQLException 1012 * if a database error happens. 1013 */ 1014 public Timestamp getTimestamp(String columnName) throws SQLException; 1015 1016 /** 1017 * Gets the value of a column specified by column name, as a {@code 1018 * java.sql.Timestamp} value. The supplied Calendar is used when mapping 1019 * the SQL {@code Timestamp} value to a Java {@code Timestamp} value. 1020 * 1021 * @param columnName 1022 * the name of the column to read. 1023 * @param cal 1024 * Calendar to use in creating the Java {@code Timestamp} value. 1025 * @return a timestamp representing the column value, {@code null} if the 1026 * column value is SQL {@code NULL}. 1027 * @throws SQLException 1028 * if a database error happens. 1029 */ 1030 public Timestamp getTimestamp(String columnName, Calendar cal) 1031 throws SQLException; 1032 1033 /** 1034 * Gets the type of the {@code ResultSet}. 1035 * 1036 * @return The {@code ResultSet} type, one of: 1037 * <ul> 1038 * <li>{@code ResultSet.TYPE_FORWARD_ONLY}</li> <li>{@code 1039 * ResultSet.TYPE_SCROLL_INSENSITIVE}</li> <li>{@code 1040 * ResultSet.TYPE_SCROLL_SENSITIVE}</li> 1041 * </ul> 1042 * @throws SQLException 1043 * if there is a database error. 1044 */ 1045 public int getType() throws SQLException; 1046 1047 /** 1048 * Gets the value of the column as an {@code InputStream} of unicode 1049 * characters. 1050 * 1051 * @deprecated Use {@link #getCharacterStream} instead. 1052 * @param columnIndex 1053 * the index of the column to read. 1054 * @return an {@code InputStream} holding the value of the column. {@code 1055 * null} if the column value is SQL {@code NULL}. 1056 * @throws SQLException 1057 * if a database error happens. 1058 */ 1059 @Deprecated 1060 public InputStream getUnicodeStream(int columnIndex) throws SQLException; 1061 1062 /** 1063 * Gets the value of the column as an {@code InputStream} of Unicode 1064 * characters. 1065 * 1066 * @deprecated Use {@link #getCharacterStream} instead. 1067 * @param columnName 1068 * the name of the column to read. 1069 * @return an {@code InputStream} holding the value of the column. {@code 1070 * null} if the column value is SQL {@code NULL}. 1071 * @throws SQLException 1072 * if a database error happens. 1073 */ 1074 @Deprecated 1075 public InputStream getUnicodeStream(String columnName) throws SQLException; 1076 1077 /** 1078 * Gets the value of a column specified by column index as a {@code 1079 * java.net.URL}. 1080 * 1081 * @param columnIndex 1082 * the index of the column to read. 1083 * @return a URL. {@code null} if the column value is SQL {@code NULL}. 1084 * @throws SQLException 1085 * if a database error happens. 1086 */ 1087 public URL getURL(int columnIndex) throws SQLException; 1088 1089 /** 1090 * Gets the value of a column specified by column name as a {@code 1091 * java.net.URL} object. 1092 * 1093 * @param columnName 1094 * the name of the column to read. 1095 * @return the column vaule as a URL. {@code null} if the column value is SQL {@code NULL}. 1096 * @throws SQLException 1097 * if a database error happens. 1098 */ 1099 public URL getURL(String columnName) throws SQLException; 1100 1101 /** 1102 * Gets the first warning generated by calls on this {@code ResultSet}. 1103 * Subsequent warnings on this {@code ResultSet} are chained to the first 1104 * one. 1105 * <p> 1106 * The warnings are cleared when a new Row is read from the {@code 1107 * ResultSet}. The warnings returned by this method are only the warnings 1108 * generated by {@code ResultSet} method calls - warnings generated by 1109 * Statement methods are held by the Statement. 1110 * <p> 1111 * An {@code SQLException} is generated if this method is called on a closed 1112 * {@code ResultSet}. 1113 * 1114 * @return an SQLWarning which is the first warning for this {@code 1115 * ResultSet}. {@code null} if there are no warnings. 1116 * @throws SQLException 1117 * if a database error happens. 1118 */ 1119 public SQLWarning getWarnings() throws SQLException; 1120 1121 /** 1122 * Insert the insert row into the {@code ResultSet} and into the underlying 1123 * database. The cursor must be set to the Insert Row before this method is 1124 * invoked. 1125 * 1126 * @throws SQLException 1127 * if a database error happens. Particular cases include the 1128 * cursor not being on the Insert Row or if any columns in the 1129 * row do not have a value where the column is declared as 1130 * not-nullable. 1131 */ 1132 public void insertRow() throws SQLException; 1133 1134 /** 1135 * Gets if the cursor is after the last row of the {@code ResultSet}. 1136 * 1137 * @return {@code true} if the cursor is after the last row in the {@code 1138 * ResultSet}, {@code false} if the cursor is at any other position 1139 * in the {@code ResultSet}. 1140 * @throws SQLException 1141 * if a database error happens. 1142 */ 1143 public boolean isAfterLast() throws SQLException; 1144 1145 /** 1146 * Gets if the cursor is before the first row of the {@code ResultSet}. 1147 * 1148 * @return {@code true} if the cursor is before the first row in the {@code 1149 * ResultSet}, {@code false} if the cursor is at any other position 1150 * in the {@code ResultSet}. 1151 * @throws SQLException 1152 * if a database error happens. 1153 */ 1154 public boolean isBeforeFirst() throws SQLException; 1155 1156 /** 1157 * Gets if the cursor is on the first row of the {@code ResultSet}. 1158 * 1159 * @return {@code true} if the cursor is on the first row in the {@code 1160 * ResultSet}, {@code false} if the cursor is at any other position 1161 * in the {@code ResultSet}. 1162 * @throws SQLException 1163 * if a database error happens. 1164 */ 1165 public boolean isFirst() throws SQLException; 1166 1167 /** 1168 * Gets if the cursor is on the last row of the {@code ResultSet} 1169 * 1170 * @return {@code true} if the cursor is on the last row in the {@code 1171 * ResultSet}, {@code false} if the cursor is at any other position 1172 * in the {@code ResultSet}. 1173 * @throws SQLException 1174 * if a database error happens. 1175 */ 1176 public boolean isLast() throws SQLException; 1177 1178 /** 1179 * Shifts the cursor position to the last row of the {@code ResultSet}. 1180 * 1181 * @return {@code true} if the new position is in a legitimate row, {@code 1182 * false} if the {@code ResultSet} contains no rows. 1183 * @throws SQLException 1184 * if there is a database error. 1185 */ 1186 public boolean last() throws SQLException; 1187 1188 /** 1189 * Moves the cursor to the remembered position, namely the 1190 * row that was the current row before a call to {@code moveToInsertRow}. 1191 * This only applies if the cursor is on the Insert Row. 1192 * 1193 * @throws SQLException 1194 * if a database error happens. 1195 */ 1196 public void moveToCurrentRow() throws SQLException; 1197 1198 /** 1199 * Moves the cursor position to the Insert Row. The current position is 1200 * remembered and the cursor is positioned at the Insert Row. The columns in 1201 * the Insert Row should be filled in with the appropriate update methods, 1202 * before calling {@code insertRow} to insert the new row into the database. 1203 * 1204 * @throws SQLException 1205 * if a database error happens. 1206 */ 1207 public void moveToInsertRow() throws SQLException; 1208 1209 /** 1210 * Shifts the cursor position down one row in this {@code ResultSet} object. 1211 * <p> 1212 * Any input streams associated with the current row are closed and any 1213 * warnings are cleared. 1214 * 1215 * @return {@code true} if the updated cursor position is pointing to a 1216 * valid row, {@code false} otherwise (i.e. when the cursor is after 1217 * the last row in the {@code ResultSet}). 1218 * @throws SQLException 1219 * if a database error happens. 1220 */ 1221 public boolean next() throws SQLException; 1222 1223 /** 1224 * Relocates the cursor position to the preceding row in this {@code 1225 * ResultSet}. 1226 * 1227 * @return {@code true} if the new position is in a legitimate row, {@code 1228 * false} if the cursor is now before the first row. 1229 * @throws SQLException 1230 * if a database error happens. 1231 */ 1232 public boolean previous() throws SQLException; 1233 1234 /** 1235 * Refreshes the current row with its most up to date value in the database. 1236 * Must not be called when the cursor is on the Insert Row. 1237 * <p> 1238 * If any columns in the current row have been updated but the {@code 1239 * updateRow} has not been called, then the updates are lost when this 1240 * method is called. 1241 * 1242 * @throws SQLException 1243 * if a database error happens., including if the current row is 1244 * the Insert row. 1245 */ 1246 public void refreshRow() throws SQLException; 1247 1248 /** 1249 * Moves the cursor position up or down by a specified number of rows. If 1250 * the new position is beyond the start row (or end row), the cursor position is 1251 * set before the first row (or, respectively, after the last row). 1252 * 1253 * @param rows 1254 * a number of rows to move the cursor - may be positive or 1255 * negative 1256 * @return {@code true} if the new cursor position is on a row, {@code 1257 * false} otherwise 1258 * @throws SQLException 1259 * if a database error happens. 1260 */ 1261 public boolean relative(int rows) throws SQLException; 1262 1263 /** 1264 * Indicates whether a row has been deleted. This method depends on whether 1265 * the JDBC driver and database can detect deletions. 1266 * 1267 * @return {@code true} if a row has been deleted and if deletions are 1268 * detected, {@code false} otherwise. 1269 * @throws SQLException 1270 * if a database error happens. 1271 */ 1272 public boolean rowDeleted() throws SQLException; 1273 1274 /** 1275 * Indicates whether the current row has had an insertion operation. This 1276 * method depends on whether the JDBC driver and database can detect 1277 * insertions. 1278 * 1279 * @return {@code true} if a row has been inserted and if insertions are 1280 * detected, {@code false} otherwise. 1281 * @throws SQLException 1282 * if a database error happens. 1283 */ 1284 public boolean rowInserted() throws SQLException; 1285 1286 /** 1287 * Indicates whether the current row has been updated. This method depends 1288 * on whether the JDBC driver and database can detect updates. 1289 * 1290 * @return {@code true} if the current row has been updated and if updates 1291 * can be detected, {@code false} otherwise. 1292 * @throws SQLException 1293 * if a database error happens. 1294 */ 1295 public boolean rowUpdated() throws SQLException; 1296 1297 /** 1298 * Indicates which direction (forward/reverse) will be used to process the 1299 * rows of this {@code ResultSet} object. This is treated as a hint by the 1300 * JDBC driver. 1301 * 1302 * @param direction 1303 * can be {@code ResultSet.FETCH_FORWARD}, {@code 1304 * ResultSet.FETCH_REVERSE}, or {@code ResultSet.FETCH_UNKNOWN} 1305 * @throws SQLException 1306 * if there is a database error. 1307 */ 1308 public void setFetchDirection(int direction) throws SQLException; 1309 1310 /** 1311 * Indicates the number of rows to fetch from the database when extra rows 1312 * are required for this {@code ResultSet}. This used as a hint to the JDBC 1313 * driver. 1314 * 1315 * @param rows 1316 * the number of rows to fetch. {@code 0} implies that the JDBC 1317 * driver can make its own decision about the fetch size. The 1318 * number should not be greater than the maximum number of rows 1319 * established by the statement that generated the {@code 1320 * ResultSet}. 1321 * @throws SQLException 1322 * if a database error happens. 1323 */ 1324 public void setFetchSize(int rows) throws SQLException; 1325 1326 /** 1327 * Updates a column specified by a column index with a {@code 1328 * java.sql.Array} value. 1329 * 1330 * @param columnIndex 1331 * the index of the column to update. 1332 * @param x 1333 * the new value for the specified column. 1334 * @throws SQLException 1335 * if a database error happens. 1336 */ 1337 public void updateArray(int columnIndex, Array x) throws SQLException; 1338 1339 /** 1340 * Updates a column specified by a column name with a {@code java.sql.Array} 1341 * value. 1342 * 1343 * @param columnName 1344 * the name of the column to update. 1345 * @param x 1346 * the new value for the specified column. 1347 * @throws SQLException 1348 * if a database error happens. 1349 */ 1350 public void updateArray(String columnName, Array x) throws SQLException; 1351 1352 /** 1353 * Updates a column specified by a column index with an ASCII stream value. 1354 * 1355 * @param columnIndex 1356 * the index of the column to update. 1357 * @param x 1358 * the new value for the specified column. 1359 * @param length 1360 * the length of the data to write from the stream 1361 * @throws SQLException 1362 * if a database error happens. 1363 */ 1364 public void updateAsciiStream(int columnIndex, InputStream x, int length) 1365 throws SQLException; 1366 1367 /** 1368 * Updates a column specified by a column name with an Ascii stream value. 1369 * 1370 * @param columnName 1371 * the name of the column to update. 1372 * @param x 1373 * the new value for the specified column. 1374 * @param length 1375 * the length of the data to write from the stream 1376 * @throws SQLException 1377 * if a database error happens. 1378 */ 1379 public void updateAsciiStream(String columnName, InputStream x, int length) 1380 throws SQLException; 1381 1382 /** 1383 * Updates a column specified by a column index with a {@code 1384 * java.sql.BigDecimal} value. 1385 * 1386 * @param columnIndex 1387 * the index of the column to update. 1388 * @param x 1389 * the new value for the specified column. 1390 * @throws SQLException 1391 * if a database error happens. 1392 */ 1393 public void updateBigDecimal(int columnIndex, BigDecimal x) 1394 throws SQLException; 1395 1396 /** 1397 * Updates a column specified by a column name with a {@code 1398 * java.sql.BigDecimal} value. 1399 * 1400 * @param columnName 1401 * the name of the column to update. 1402 * @param x 1403 * the new value for the specified column. 1404 * @throws SQLException 1405 * if a database error happens. 1406 */ 1407 public void updateBigDecimal(String columnName, BigDecimal x) 1408 throws SQLException; 1409 1410 /** 1411 * Updates a column specified by a column index with a binary stream value. 1412 * 1413 * @param columnIndex 1414 * the index of the column to update. 1415 * @param x 1416 * the new value for the specified column. 1417 * @param length 1418 * the number of bytes to be read from the the stream. 1419 * @throws SQLException 1420 * if a database error happens. 1421 */ 1422 public void updateBinaryStream(int columnIndex, InputStream x, int length) 1423 throws SQLException; 1424 1425 /** 1426 * Updates a column specified by a column name with a binary stream value. 1427 * 1428 * @param columnName 1429 * the name of the column to update. 1430 * @param x 1431 * the new value for the specified column. 1432 * @param length 1433 * he number of bytes to be read from the the stream. 1434 * @throws SQLException 1435 * if a database error happens. 1436 */ 1437 public void updateBinaryStream(String columnName, InputStream x, int length) 1438 throws SQLException; 1439 1440 /** 1441 * Updates a column specified by a column index with a {@code java.sql.Blob} 1442 * value. 1443 * 1444 * @param columnIndex 1445 * the index of the column to update. 1446 * @param x 1447 * the new value for the specified column. 1448 * @throws SQLException 1449 * if a database error happens. 1450 */ 1451 public void updateBlob(int columnIndex, Blob x) throws SQLException; 1452 1453 /** 1454 * Updates a column specified by a column name with a {@code java.sql.Blob} 1455 * value. 1456 * 1457 * @param columnName 1458 * the name of the column to update. 1459 * @param x 1460 * the new value for the specified column. 1461 * @throws SQLException 1462 * if a database error happens. 1463 */ 1464 public void updateBlob(String columnName, Blob x) throws SQLException; 1465 1466 /** 1467 * Updates a column specified by a column index with a {@code boolean} 1468 * value. 1469 * 1470 * @param columnIndex 1471 * the index of the column to update. 1472 * @param x 1473 * the new value for the specified column. 1474 * @throws SQLException 1475 * if a database error happens. 1476 */ 1477 public void updateBoolean(int columnIndex, boolean x) throws SQLException; 1478 1479 /** 1480 * Updates a column specified by a column name with a {@code boolean} value. 1481 * 1482 * @param columnName 1483 * the name of the column to update. 1484 * @param x 1485 * the new value for the specified column. 1486 * @throws SQLException 1487 * if a database error happens. 1488 */ 1489 public void updateBoolean(String columnName, boolean x) throws SQLException; 1490 1491 /** 1492 * Updates a column specified by a column index with a {@code byte} value. 1493 * 1494 * @param columnIndex 1495 * the index of the column to update. 1496 * @param x 1497 * the new value for the specified column. 1498 * @throws SQLException 1499 * if a database error happens. 1500 */ 1501 public void updateByte(int columnIndex, byte x) throws SQLException; 1502 1503 /** 1504 * Updates a column specified by a column name with a {@code byte} value. 1505 * 1506 * @param columnName 1507 * the name of the column to update. 1508 * @param x 1509 * the new value for the specified column. 1510 * @throws SQLException 1511 * if a database error happens. 1512 */ 1513 public void updateByte(String columnName, byte x) throws SQLException; 1514 1515 /** 1516 * Updates a column specified by a column index with a {@code byte} array 1517 * value. 1518 * 1519 * @param columnIndex 1520 * the index of the column to update. 1521 * @param x 1522 * the new value for the specified column. 1523 * @throws SQLException 1524 * if a database error happens. 1525 */ 1526 public void updateBytes(int columnIndex, byte[] x) throws SQLException; 1527 1528 /** 1529 * Updates a column specified by a column name with a byte array value. 1530 * 1531 * @param columnName 1532 * the name of the column to update. 1533 * @param x 1534 * the new value for the specified column. 1535 * @throws SQLException 1536 * if a database error happens. 1537 */ 1538 public void updateBytes(String columnName, byte[] x) throws SQLException; 1539 1540 /** 1541 * Updates a column specified by a column index with a character stream 1542 * value. 1543 * 1544 * @param columnIndex 1545 * the index of the column to update. 1546 * @param x 1547 * the new value for the specified column. 1548 * @param length 1549 * the length of data to write from the stream 1550 * @throws SQLException 1551 * if a database error happens. 1552 */ 1553 public void updateCharacterStream(int columnIndex, Reader x, int length) 1554 throws SQLException; 1555 1556 /** 1557 * Updates a column specified by a column name with a character stream 1558 * value. 1559 * 1560 * @param columnName 1561 * the name of the column to update. 1562 * @param reader 1563 * the new value for the specified column. 1564 * @param length 1565 * the length of data to write from the Reader 1566 * @throws SQLException 1567 * if a database error happens. 1568 */ 1569 public void updateCharacterStream(String columnName, Reader reader, 1570 int length) throws SQLException; 1571 1572 /** 1573 * Updates a column specified by a column index with a {@code java.sql.Clob} 1574 * value. 1575 * 1576 * @param columnIndex 1577 * the index of the column to update. 1578 * @param x 1579 * the new value for the specified column. 1580 * @throws SQLException 1581 * if a database error happens. 1582 */ 1583 public void updateClob(int columnIndex, Clob x) throws SQLException; 1584 1585 /** 1586 * Updates a column specified by a column name with a {@code java.sql.Clob} 1587 * value. 1588 * 1589 * @param columnName 1590 * the name of the column to update. 1591 * @param x 1592 * the new value for the specified column. 1593 * @throws SQLException 1594 * if a database error happens. 1595 */ 1596 public void updateClob(String columnName, Clob x) throws SQLException; 1597 1598 /** 1599 * Updates a column specified by a column index with a {@code java.sql.Date} 1600 * value. 1601 * 1602 * @param columnIndex 1603 * the index of the column to update. 1604 * @param x 1605 * the new value for the specified column. 1606 * @throws SQLException 1607 * if a database error happens. 1608 */ 1609 public void updateDate(int columnIndex, Date x) throws SQLException; 1610 1611 /** 1612 * Updates a column specified by a column name with a {@code java.sql.Date} 1613 * value. 1614 * 1615 * @param columnName 1616 * the name of the column to update. 1617 * @param x 1618 * the new value for the specified column. 1619 * @throws SQLException 1620 * if a database error happens. 1621 */ 1622 public void updateDate(String columnName, Date x) throws SQLException; 1623 1624 /** 1625 * Updates a column specified by a column index with a {@code double} value. 1626 * 1627 * @param columnIndex 1628 * the index of the column to update. 1629 * @param x 1630 * the new value for the specified column. 1631 * @throws SQLException 1632 * if a database error happens. 1633 */ 1634 public void updateDouble(int columnIndex, double x) throws SQLException; 1635 1636 /** 1637 * Updates a column specified by a column name with a {@code double} value. 1638 * 1639 * @param columnName 1640 * the name of the column to update. 1641 * @param x 1642 * the new value for the specified column. 1643 * @throws SQLException 1644 * if a database error happens. 1645 */ 1646 public void updateDouble(String columnName, double x) throws SQLException; 1647 1648 /** 1649 * Updates a column specified by a column index with a {@code float} value. 1650 * 1651 * @param columnIndex 1652 * the index of the column to update. 1653 * @param x 1654 * the new value for the specified column. 1655 * @throws SQLException 1656 * if a database error happens. 1657 */ 1658 public void updateFloat(int columnIndex, float x) throws SQLException; 1659 1660 /** 1661 * Updates a column specified by a column name with a {@code float} value. 1662 * 1663 * @param columnName 1664 * the name of the column to update. 1665 * @param x 1666 * the new value for the specified column. 1667 * @throws SQLException 1668 * if a database error happens. 1669 */ 1670 public void updateFloat(String columnName, float x) throws SQLException; 1671 1672 /** 1673 * Updates a column specified by a column index with an {@code int} value. 1674 * 1675 * @param columnIndex 1676 * the index of the column to update. 1677 * @param x 1678 * the new value for the specified column. 1679 * @throws SQLException 1680 * if a database error happens. 1681 */ 1682 public void updateInt(int columnIndex, int x) throws SQLException; 1683 1684 /** 1685 * Updates a column specified by a column name with an {@code int} value. 1686 * 1687 * @param columnName 1688 * the name of the column to update. 1689 * @param x 1690 * the new value for the specified column. 1691 * @throws SQLException 1692 * if a database error happens. 1693 */ 1694 public void updateInt(String columnName, int x) throws SQLException; 1695 1696 /** 1697 * Updates a column specified by a column index with a {@code long} value. 1698 * 1699 * @param columnIndex 1700 * the index of the column to update. 1701 * @param x 1702 * the new value for the specified column.. 1703 * @throws SQLException 1704 * if a database error happens. 1705 */ 1706 public void updateLong(int columnIndex, long x) throws SQLException; 1707 1708 /** 1709 * Updates a column specified by a column name with a {@code long} value. 1710 * 1711 * @param columnName 1712 * the name of the column to update. 1713 * @param x 1714 * the new value for the specified column. 1715 * @throws SQLException 1716 * if a database error happens. 1717 */ 1718 public void updateLong(String columnName, long x) throws SQLException; 1719 1720 /** 1721 * Updates a column specified by a column index with a {@code null} value. 1722 * 1723 * @param columnIndex 1724 * the index of the column to update. 1725 * @throws SQLException 1726 * if a database error happens. 1727 */ 1728 public void updateNull(int columnIndex) throws SQLException; 1729 1730 /** 1731 * Updates a column specified by a column name with a {@code null} value. 1732 * 1733 * @param columnName 1734 * the name of the column to update. 1735 * @throws SQLException 1736 * if a database error happens. 1737 */ 1738 public void updateNull(String columnName) throws SQLException; 1739 1740 /** 1741 * Updates a column specified by a column index with an {@code Object} 1742 * value. 1743 * 1744 * @param columnIndex 1745 * the index of the column to update. 1746 * @param x 1747 * the new value for the specified column. 1748 * @throws SQLException 1749 * if a database error happens. 1750 */ 1751 public void updateObject(int columnIndex, Object x) throws SQLException; 1752 1753 /** 1754 * Updates a column specified by a column index with an {@code Object} 1755 * value. 1756 * 1757 * @param columnIndex 1758 * the index of the column to update. 1759 * @param x 1760 * the new value for the specified column. 1761 * @param scale 1762 * for the types {@code java.sql.Types.DECIMAL} or {@code 1763 * java.sql.Types.NUMERIC}, this specifies the number of digits 1764 * after the decimal point. 1765 * @throws SQLException 1766 * if a database error happens. 1767 */ 1768 public void updateObject(int columnIndex, Object x, int scale) 1769 throws SQLException; 1770 1771 /** 1772 * Updates a column specified by a column name with an {@code Object} value. 1773 * 1774 * @param columnName 1775 * the name of the column to update. 1776 * @param x 1777 * the new value for the specified column. 1778 * @throws SQLException 1779 * if a database error happens. 1780 */ 1781 public void updateObject(String columnName, Object x) throws SQLException; 1782 1783 /** 1784 * Updates a column specified by a column name with an {@code Object} value. 1785 * 1786 * @param columnName 1787 * the name of the column to update. 1788 * @param x 1789 * the new value for the specified column. 1790 * @param scale 1791 * for the types {@code java.sql.Types.DECIMAL} or {@code 1792 * java.sql.Types.NUMERIC}, this specifies the number of digits 1793 * after the decimal point. 1794 * @throws SQLException 1795 * if a database error happens. 1796 */ 1797 public void updateObject(String columnName, Object x, int scale) 1798 throws SQLException; 1799 1800 /** 1801 * Updates a column specified by a column index with a {@code java.sql.Ref} 1802 * value. 1803 * 1804 * @param columnIndex 1805 * the index of the column to update. 1806 * @param x 1807 * the new value for the specified column. 1808 * @throws SQLException 1809 * if a database error happens. 1810 */ 1811 public void updateRef(int columnIndex, Ref x) throws SQLException; 1812 1813 /** 1814 * Updates a column specified by a column name with a {@code java.sql.Ref} 1815 * value. 1816 * 1817 * @param columnName 1818 * the name of the column to update. 1819 * @param x 1820 * the new value for the specified column. 1821 * @throws SQLException 1822 * if a database error happens. 1823 */ 1824 public void updateRef(String columnName, Ref x) throws SQLException; 1825 1826 /** 1827 * Updates the database with the new contents of the current row of this 1828 * {@code ResultSet} object. 1829 * 1830 * @throws SQLException 1831 * if a database error happens. 1832 */ 1833 public void updateRow() throws SQLException; 1834 1835 /** 1836 * Updates a column specified by a column index with a {@code short} value. 1837 * 1838 * @param columnIndex 1839 * the index of the column to update. 1840 * @param x 1841 * the new value for the specified column. 1842 * @throws SQLException 1843 * if a database error happens. 1844 */ 1845 public void updateShort(int columnIndex, short x) throws SQLException; 1846 1847 /** 1848 * Updates a column specified by a column name with a {@code short} value. 1849 * 1850 * @param columnName 1851 * the name of the column to update. 1852 * @param x 1853 * the new value for the specified column. 1854 * @throws SQLException 1855 * if a database error happens. 1856 */ 1857 public void updateShort(String columnName, short x) throws SQLException; 1858 1859 /** 1860 * Updates a column specified by a column index with a {@code String} value. 1861 * 1862 * @param columnIndex 1863 * the index of the column to update. 1864 * @param x 1865 * the new value for the specified column. 1866 * @throws SQLException 1867 * if a database error happens. 1868 */ 1869 public void updateString(int columnIndex, String x) throws SQLException; 1870 1871 /** 1872 * Updates a column specified by a column name with a {@code String} value. 1873 * 1874 * @param columnName 1875 * the name of the column to update. 1876 * @param x 1877 * the new value for the specified column. 1878 * @throws SQLException 1879 * if a database error happens. 1880 */ 1881 public void updateString(String columnName, String x) throws SQLException; 1882 1883 /** 1884 * Updates a column specified by a column index with a {@code Time} value. 1885 * 1886 * @param columnIndex 1887 * the index of the column to update. 1888 * @param x 1889 * the new value for the specified column. 1890 * @throws SQLException 1891 * if a database error happens. 1892 */ 1893 public void updateTime(int columnIndex, Time x) throws SQLException; 1894 1895 /** 1896 * Updates a column specified by a column name with a {@code Time} value. 1897 * 1898 * @param columnName 1899 * the name of the column to update. 1900 * @param x 1901 * the new value for the specified column. 1902 * @throws SQLException 1903 * if a database error happens. 1904 */ 1905 public void updateTime(String columnName, Time x) throws SQLException; 1906 1907 /** 1908 * Updates a column specified by a column index with a {@code Timestamp} 1909 * value. 1910 * 1911 * @param columnIndex 1912 * the index of the column to update. 1913 * @param x 1914 * the new timestamp value for the specified column. 1915 * @throws SQLException 1916 * if a database error happens. 1917 */ 1918 public void updateTimestamp(int columnIndex, Timestamp x) 1919 throws SQLException; 1920 1921 /** 1922 * Updates a column specified by column name with a {@code Timestamp} value. 1923 * 1924 * @param columnName 1925 * the name of the column to update. 1926 * @param x 1927 * the new timestamp value for the specified column. 1928 * @throws SQLException 1929 * if a database error happens. 1930 */ 1931 public void updateTimestamp(String columnName, Timestamp x) 1932 throws SQLException; 1933 1934 /** 1935 * Determines whether the last column read from this {@code ResultSet} 1936 * contained SQL {@code NULL}. 1937 * 1938 * @return {@code {@code true} if the last column contained SQL {@code 1939 * NULL}, {@code false} otherwise 1940 * @throws SQLException 1941 * if a database error happens. 1942 */ 1943 public boolean wasNull() throws SQLException; 1944 1945 /** 1946 * Returns a {@code RowId} corresponding to the SQL ROWID at the 1-based {@code columnIndex}. 1947 * @throws SQLException 1948 */ 1949 public RowId getRowId(int columnIndex) throws SQLException; 1950 1951 /** 1952 * Returns a {@code RowId} corresponding to the SQL ROWID at the named column. 1953 * @throws SQLException 1954 */ 1955 public RowId getRowId(String columnLabel) throws SQLException; 1956 1957 /** 1958 * Updates the value at the 1-based {@code columnIndex}. 1959 * The underlying database isn't changed until the next row update or insert operation. 1960 * @throws SQLException 1961 */ 1962 public void updateRowId(int columnIndex, RowId value) throws SQLException; 1963 1964 /** 1965 * Updates the value in the named column. 1966 * The underlying database isn't changed until the next row update or insert operation. 1967 * @throws SQLException 1968 */ 1969 public void updateRowId(String columnLabel, RowId value) throws SQLException; 1970 1971 /** 1972 * Returns the holdability of this result set: {@link #HOLD_CURSORS_OVER_COMMIT} or 1973 * {@link #CLOSE_CURSORS_AT_COMMIT}. 1974 * @throws SQLException 1975 */ 1976 public int getHoldability() throws SQLException; 1977 1978 /** 1979 * Returns true if this result set has been closed, false otherwise. 1980 * @throws SQLException 1981 */ 1982 public boolean isClosed() throws SQLException; 1983 1984 /** 1985 * Updates the value at the 1-based {@code columnIndex}. 1986 * The underlying database isn't changed until the next row update or insert operation. 1987 * @throws SQLException 1988 */ 1989 public void updateNString(int columnIndex, String nString) throws SQLException; 1990 1991 /** 1992 * Updates the value in the named column. 1993 * The underlying database isn't changed until the next row update or insert operation. 1994 * @throws SQLException 1995 */ 1996 public void updateNString(String columnLabel, String nString) throws SQLException; 1997 1998 /** 1999 * Updates the value at the 1-based {@code columnIndex}. 2000 * The underlying database isn't changed until the next row update or insert operation. 2001 * @throws SQLException 2002 */ 2003 public void updateNClob(int columnIndex, NClob nClob) throws SQLException; 2004 2005 /** 2006 * Updates the value in the named column. 2007 * The underlying database isn't changed until the next row update or insert operation. 2008 * @throws SQLException 2009 */ 2010 public void updateNClob(String columnLabel, NClob nClob) throws SQLException; 2011 2012 /** 2013 * Returns an {@code NClob} corresponding to the value at the 1-based {@code columnIndex}. 2014 * @throws SQLException 2015 */ 2016 public NClob getNClob(int columnIndex) throws SQLException; 2017 2018 /** 2019 * Returns an {@code NClob} corresponding to the value in the named column. 2020 * @throws SQLException 2021 */ 2022 public NClob getNClob(String columnLabel) throws SQLException; 2023 2024 /** 2025 * Returns an {@code SQLXML} corresponding to the value at the 1-based {@code columnIndex}. 2026 * @throws SQLException 2027 */ 2028 public SQLXML getSQLXML(int columnIndex) throws SQLException; 2029 2030 /** 2031 * Returns an {@code SQLXML} corresponding to the value in the named column. 2032 * @throws SQLException 2033 */ 2034 public SQLXML getSQLXML(String columnLabel) throws SQLException; 2035 2036 /** 2037 * Updates the value at the 1-based {@code columnIndex}. 2038 * The underlying database isn't changed until the next row update or insert operation. 2039 * @throws SQLException 2040 */ 2041 public void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException; 2042 2043 /** 2044 * Updates the value in the named column. 2045 * The underlying database isn't changed until the next row update or insert operation. 2046 * @throws SQLException 2047 */ 2048 public void updateSQLXML(String columnLabel, SQLXML xmlObject) throws SQLException; 2049 2050 /** 2051 * Returns a {@code String} corresponding to the value at the 1-based {@code columnIndex}. 2052 * @throws SQLException 2053 */ 2054 public String getNString(int columnIndex) throws SQLException; 2055 2056 /** 2057 * Returns a {@code String} corresponding to the value in the named column. 2058 * @throws SQLException 2059 */ 2060 public String getNString(String columnLabel) throws SQLException; 2061 2062 /** 2063 * Returns a {@code Reader} corresponding to the value at the 1-based {@code columnIndex}. 2064 * @throws SQLException 2065 */ 2066 public Reader getNCharacterStream(int columnIndex) throws SQLException; 2067 2068 /** 2069 * Returns a {@code Reader} corresponding to the value in the named column. 2070 * @throws SQLException 2071 */ 2072 public Reader getNCharacterStream(String columnLabel) throws SQLException; 2073 2074 /** 2075 * Updates the value at the 1-based {@code columnIndex}. 2076 * The underlying database isn't changed until the next row update or insert operation. 2077 * @throws SQLException 2078 */ 2079 public void updateNCharacterStream(int columnIndex, Reader x, long length) throws SQLException; 2080 2081 /** 2082 * Updates the value in the named column. 2083 * The underlying database isn't changed until the next row update or insert operation. 2084 * @throws SQLException 2085 */ 2086 public void updateNCharacterStream(String columnLabel, Reader reader, long length) throws SQLException; 2087 2088 /** 2089 * Updates the value at the 1-based {@code columnIndex}. 2090 * The underlying database isn't changed until the next row update or insert operation. 2091 * @throws SQLException 2092 */ 2093 public void updateAsciiStream(int columnIndex, InputStream x, long length) throws SQLException; 2094 2095 /** 2096 * Updates the value at the 1-based {@code columnIndex}. 2097 * The underlying database isn't changed until the next row update or insert operation. 2098 * @throws SQLException 2099 */ 2100 public void updateBinaryStream(int columnIndex, InputStream x, long length) throws SQLException; 2101 2102 /** 2103 * Updates the value at the 1-based {@code columnIndex}. 2104 * The underlying database isn't changed until the next row update or insert operation. 2105 * @throws SQLException 2106 */ 2107 public void updateCharacterStream(int columnIndex, Reader x, long length) throws SQLException; 2108 2109 /** 2110 * Updates the value in the named column. 2111 * The underlying database isn't changed until the next row update or insert operation. 2112 * @throws SQLException 2113 */ 2114 public void updateAsciiStream(String columnLabel, InputStream x, long length) throws SQLException; 2115 2116 /** 2117 * Updates the value in the named column. 2118 * The underlying database isn't changed until the next row update or insert operation. 2119 * @throws SQLException 2120 */ 2121 public void updateBinaryStream(String columnLabel, InputStream x, long length) throws SQLException; 2122 2123 /** 2124 * Updates the value in the named column. 2125 * The underlying database isn't changed until the next row update or insert operation. 2126 * @throws SQLException 2127 */ 2128 public void updateCharacterStream(String columnLabel, Reader reader, long length) throws SQLException; 2129 2130 /** 2131 * Updates the value at the 1-based {@code columnIndex}. 2132 * The underlying database isn't changed until the next row update or insert operation. 2133 * @throws SQLException 2134 */ 2135 public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException; 2136 2137 /** 2138 * Updates the value in the named column. 2139 * The underlying database isn't changed until the next row update or insert operation. 2140 * @throws SQLException 2141 */ 2142 public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException; 2143 2144 /** 2145 * Updates the value at the 1-based {@code columnIndex}. 2146 * The underlying database isn't changed until the next row update or insert operation. 2147 * @throws SQLException 2148 */ 2149 public void updateClob(int columnIndex, Reader reader, long length) throws SQLException; 2150 2151 /** 2152 * Updates the value in the named column. 2153 * The underlying database isn't changed until the next row update or insert operation. 2154 * @throws SQLException 2155 */ 2156 public void updateClob(String columnLabel, Reader reader, long length) throws SQLException; 2157 2158 /** 2159 * Updates the value at the 1-based {@code columnIndex}. 2160 * The underlying database isn't changed until the next row update or insert operation. 2161 * @throws SQLException 2162 */ 2163 public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException; 2164 2165 /** 2166 * Updates the value in the named column. 2167 * The underlying database isn't changed until the next row update or insert operation. 2168 * @throws SQLException 2169 */ 2170 public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException; 2171 2172 /** 2173 * Updates the value at the 1-based {@code columnIndex}. 2174 * The underlying database isn't changed until the next row update or insert operation. 2175 * @throws SQLException 2176 */ 2177 public void updateNCharacterStream(int columnIndex, Reader x) throws SQLException; 2178 2179 /** 2180 * Updates the value in the named column. 2181 * The underlying database isn't changed until the next row update or insert operation. 2182 * @throws SQLException 2183 */ 2184 public void updateNCharacterStream(String columnLabel, Reader reader) throws SQLException; 2185 2186 /** 2187 * Updates the value at the 1-based {@code columnIndex}. 2188 * The underlying database isn't changed until the next row update or insert operation. 2189 * @throws SQLException 2190 */ 2191 public void updateAsciiStream(int columnIndex, InputStream x) throws SQLException; 2192 2193 /** 2194 * Updates the value at the 1-based {@code columnIndex}. 2195 * The underlying database isn't changed until the next row update or insert operation. 2196 * @throws SQLException 2197 */ 2198 public void updateBinaryStream(int columnIndex, InputStream x) throws SQLException; 2199 2200 /** 2201 * Updates the value at the 1-based {@code columnIndex}. 2202 * The underlying database isn't changed until the next row update or insert operation. 2203 * @throws SQLException 2204 */ 2205 public void updateCharacterStream(int columnIndex, Reader x) throws SQLException; 2206 2207 /** 2208 * Updates the value in the named column. 2209 * The underlying database isn't changed until the next row update or insert operation. 2210 * @throws SQLException 2211 */ 2212 public void updateAsciiStream(String columnLabel, InputStream x) throws SQLException; 2213 2214 /** 2215 * Updates the value in the named column. 2216 * The underlying database isn't changed until the next row update or insert operation. 2217 * @throws SQLException 2218 */ 2219 public void updateBinaryStream(String columnLabel, InputStream x) throws SQLException; 2220 2221 /** 2222 * Updates the value in the named column. 2223 * The underlying database isn't changed until the next row update or insert operation. 2224 * @throws SQLException 2225 */ 2226 public void updateCharacterStream(String columnLabel, Reader reader) throws SQLException; 2227 2228 /** 2229 * Updates the value at the 1-based {@code columnIndex}. 2230 * The underlying database isn't changed until the next row update or insert operation. 2231 * @throws SQLException 2232 */ 2233 public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException; 2234 2235 /** 2236 * Updates the value in the named column. 2237 * The underlying database isn't changed until the next row update or insert operation. 2238 * @throws SQLException 2239 */ 2240 public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException; 2241 2242 /** 2243 * Updates the value at the 1-based {@code columnIndex}. 2244 * The underlying database isn't changed until the next row update or insert operation. 2245 * @throws SQLException 2246 */ 2247 public void updateClob(int columnIndex, Reader reader) throws SQLException; 2248 2249 /** 2250 * Updates the value in the named column. 2251 * The underlying database isn't changed until the next row update or insert operation. 2252 * @throws SQLException 2253 */ 2254 public void updateClob(String columnLabel, Reader reader) throws SQLException; 2255 2256 /** 2257 * Updates the value at the 1-based {@code columnIndex}. 2258 * The underlying database isn't changed until the next row update or insert operation. 2259 * @throws SQLException 2260 */ 2261 public void updateNClob(int columnIndex, Reader reader) throws SQLException; 2262 2263 /** 2264 * Updates the value in the named column. 2265 * The underlying database isn't changed until the next row update or insert operation. 2266 * @throws SQLException 2267 */ 2268 public void updateNClob(String columnLabel, Reader reader) throws SQLException; 2269} 2270