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