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