0001 /*
0002 * Copyright 1996-2006 Sun Microsystems, Inc. All Rights Reserved.
0003 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
0004 *
0005 * This code is free software; you can redistribute it and/or modify it
0006 * under the terms of the GNU General Public License version 2 only, as
0007 * published by the Free Software Foundation. Sun designates this
0008 * particular file as subject to the "Classpath" exception as provided
0009 * by Sun in the LICENSE file that accompanied this code.
0010 *
0011 * This code is distributed in the hope that it will be useful, but WITHOUT
0012 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
0013 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
0014 * version 2 for more details (a copy is included in the LICENSE file that
0015 * accompanied this code).
0016 *
0017 * You should have received a copy of the GNU General Public License version
0018 * 2 along with this work; if not, write to the Free Software Foundation,
0019 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
0020 *
0021 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
0022 * CA 95054 USA or visit www.sun.com if you need additional information or
0023 * have any questions.
0024 */
0025
0026 package java.sql;
0027
0028 import java.math.BigDecimal;
0029 import java.util.Calendar;
0030 import java.io.Reader;
0031 import java.io.InputStream;
0032
0033 /**
0034 * A table of data representing a database result set, which
0035 * is usually generated by executing a statement that queries the database.
0036 *
0037 * <P>A <code>ResultSet</code> object maintains a cursor pointing
0038 * to its current row of data. Initially the cursor is positioned
0039 * before the first row. The <code>next</code> method moves the
0040 * cursor to the next row, and because it returns <code>false</code>
0041 * when there are no more rows in the <code>ResultSet</code> object,
0042 * it can be used in a <code>while</code> loop to iterate through
0043 * the result set.
0044 * <P>
0045 * A default <code>ResultSet</code> object is not updatable and
0046 * has a cursor that moves forward only. Thus, you can
0047 * iterate through it only once and only from the first row to the
0048 * last row. It is possible to
0049 * produce <code>ResultSet</code> objects that are scrollable and/or
0050 * updatable. The following code fragment, in which <code>con</code>
0051 * is a valid <code>Connection</code> object, illustrates how to make
0052 * a result set that is scrollable and insensitive to updates by others, and
0053 * that is updatable. See <code>ResultSet</code> fields for other
0054 * options.
0055 * <PRE>
0056 *
0057 * Statement stmt = con.createStatement(
0058 * ResultSet.TYPE_SCROLL_INSENSITIVE,
0059 * ResultSet.CONCUR_UPDATABLE);
0060 * ResultSet rs = stmt.executeQuery("SELECT a, b FROM TABLE2");
0061 * // rs will be scrollable, will not show changes made by others,
0062 * // and will be updatable
0063 *
0064 * </PRE>
0065 * The <code>ResultSet</code> interface provides
0066 * <i>getter</i> methods (<code>getBoolean</code>, <code>getLong</code>, and so on)
0067 * for retrieving column values from the current row.
0068 * Values can be retrieved using either the index number of the
0069 * column or the name of the column. In general, using the
0070 * column index will be more efficient. Columns are numbered from 1.
0071 * For maximum portability, result set columns within each row should be
0072 * read in left-to-right order, and each column should be read only once.
0073 *
0074 * <P>For the getter methods, a JDBC driver attempts
0075 * to convert the underlying data to the Java type specified in the
0076 * getter method and returns a suitable Java value. The JDBC specification
0077 * has a table showing the allowable mappings from SQL types to Java types
0078 * that can be used by the <code>ResultSet</code> getter methods.
0079 * <P>
0080 * <P>Column names used as input to getter methods are case
0081 * insensitive. When a getter method is called with
0082 * a column name and several columns have the same name,
0083 * the value of the first matching column will be returned.
0084 * The column name option is
0085 * designed to be used when column names are used in the SQL
0086 * query that generated the result set.
0087 * For columns that are NOT explicitly named in the query, it
0088 * is best to use column numbers. If column names are used, the
0089 * programmer should take care to guarantee that they uniquely refer to
0090 * the intended columns, which can be assured with the SQL <i>AS</i> clause.
0091 * <P>
0092 * A set of updater methods were added to this interface
0093 * in the JDBC 2.0 API (Java<sup><font size=-2>TM</font></sup> 2 SDK,
0094 * Standard Edition, version 1.2). The comments regarding parameters
0095 * to the getter methods also apply to parameters to the
0096 * updater methods.
0097 *<P>
0098 * The updater methods may be used in two ways:
0099 * <ol>
0100 * <LI>to update a column value in the current row. In a scrollable
0101 * <code>ResultSet</code> object, the cursor can be moved backwards
0102 * and forwards, to an absolute position, or to a position
0103 * relative to the current row.
0104 * The following code fragment updates the <code>NAME</code> column
0105 * in the fifth row of the <code>ResultSet</code> object
0106 * <code>rs</code> and then uses the method <code>updateRow</code>
0107 * to update the data source table from which <code>rs</code> was derived.
0108 * <PRE>
0109 *
0110 * rs.absolute(5); // moves the cursor to the fifth row of rs
0111 * rs.updateString("NAME", "AINSWORTH"); // updates the
0112 * // <code>NAME</code> column of row 5 to be <code>AINSWORTH</code>
0113 * rs.updateRow(); // updates the row in the data source
0114 *
0115 * </PRE>
0116 * <LI>to insert column values into the insert row. An updatable
0117 * <code>ResultSet</code> object has a special row associated with
0118 * it that serves as a staging area for building a row to be inserted.
0119 * The following code fragment moves the cursor to the insert row, builds
0120 * a three-column row, and inserts it into <code>rs</code> and into
0121 * the data source table using the method <code>insertRow</code>.
0122 * <PRE>
0123 *
0124 * rs.moveToInsertRow(); // moves cursor to the insert row
0125 * rs.updateString(1, "AINSWORTH"); // updates the
0126 * // first column of the insert row to be <code>AINSWORTH</code>
0127 * rs.updateInt(2,35); // updates the second column to be <code>35</code>
0128 * rs.updateBoolean(3, true); // updates the third column to <code>true</code>
0129 * rs.insertRow();
0130 * rs.moveToCurrentRow();
0131 *
0132 * </PRE>
0133 * </ol>
0134 * <P>A <code>ResultSet</code> object is automatically closed when the
0135 * <code>Statement</code> object that
0136 * generated it is closed, re-executed, or used
0137 * to retrieve the next result from a sequence of multiple results.
0138 *
0139 * <P>The number, types and properties of a <code>ResultSet</code>
0140 * object's columns are provided by the <code>ResulSetMetaData</code>
0141 * object returned by the <code>ResultSet.getMetaData</code> method.
0142 *
0143 * @see Statement#executeQuery
0144 * @see Statement#getResultSet
0145 * @see ResultSetMetaData
0146 */
0147
0148 public interface ResultSet extends Wrapper {
0149
0150 /**
0151 * Moves the cursor froward one row from its current position.
0152 * A <code>ResultSet</code> cursor is initially positioned
0153 * before the first row; the first call to the method
0154 * <code>next</code> makes the first row the current row; the
0155 * second call makes the second row the current row, and so on.
0156 * <p>
0157 * When a call to the <code>next</code> method returns <code>false</code>,
0158 * the cursor is positioned after the last row. Any
0159 * invocation of a <code>ResultSet</code> method which requires a
0160 * current row will result in a <code>SQLException</code> being thrown.
0161 * If the result set type is <code>TYPE_FORWARD_ONLY</code>, it is vendor specified
0162 * whether their JDBC driver implementation will return <code>false</code> or
0163 * throw an <code>SQLException</code> on a
0164 * subsequent call to <code>next</code>.
0165 *
0166 * <P>If an input stream is open for the current row, a call
0167 * to the method <code>next</code> will
0168 * implicitly close it. A <code>ResultSet</code> object's
0169 * warning chain is cleared when a new row is read.
0170 *
0171 * @return <code>true</code> if the new current row is valid;
0172 * <code>false</code> if there are no more rows
0173 * @exception SQLException if a database access error occurs or this method is
0174 * called on a closed result set
0175 */
0176 boolean next() throws SQLException;
0177
0178 /**
0179 * Releases this <code>ResultSet</code> object's database and
0180 * JDBC resources immediately instead of waiting for
0181 * this to happen when it is automatically closed.
0182 *
0183 * <P>The closing of a <code>ResultSet</code> object does <strong>not</strong> close the <code>Blob</code>,
0184 * <code>Clob</code> or <code>NClob</code> objects created by the <code>ResultSet</code>. <code>Blob</code>,
0185 * <code>Clob</code> or <code>NClob</code> objects remain valid for at least the duration of the
0186 * transaction in which they are creataed, unless their <code>free</code> method is invoked.
0187 *<p>
0188 * When a <code>ResultSet</code> is closed, any <code>ResultSetMetaData</code>
0189 * instances that were created by calling the <code>getMetaData</code>
0190 * method remain accessible.
0191 *
0192 * <P><B>Note:</B> A <code>ResultSet</code> object
0193 * is automatically closed by the
0194 * <code>Statement</code> object that generated it when
0195 * that <code>Statement</code> object is closed,
0196 * re-executed, or is used to retrieve the next result from a
0197 * sequence of multiple results.
0198 *<p>
0199 * Calling the method <code>close</code> on a <code>ResultSet</code>
0200 * object that is already closed is a no-op.
0201 * <P>
0202 * <p>
0203 *
0204 * @exception SQLException if a database access error occurs
0205 */
0206 void close() throws SQLException;
0207
0208 /**
0209 * Reports whether
0210 * the last column read had a value of SQL <code>NULL</code>.
0211 * Note that you must first call one of the getter methods
0212 * on a column to try to read its value and then call
0213 * the method <code>wasNull</code> to see if the value read was
0214 * SQL <code>NULL</code>.
0215 *
0216 * @return <code>true</code> if the last column value read was SQL
0217 * <code>NULL</code> and <code>false</code> otherwise
0218 * @exception SQLException if a database access error occurs or this method is
0219 * called on a closed result set
0220 */
0221 boolean wasNull() throws SQLException;
0222
0223 // Methods for accessing results by column index
0224
0225 /**
0226 * Retrieves the value of the designated column in the current row
0227 * of this <code>ResultSet</code> object as
0228 * a <code>String</code> in the Java programming language.
0229 *
0230 * @param columnIndex the first column is 1, the second is 2, ...
0231 * @return the column value; if the value is SQL <code>NULL</code>, the
0232 * value returned is <code>null</code>
0233 * @exception SQLException if the columnIndex is not valid;
0234 * if a database access error occurs or this method is
0235 * called on a closed result set
0236 */
0237 String getString(int columnIndex) throws SQLException;
0238
0239 /**
0240 * Retrieves the value of the designated column in the current row
0241 * of this <code>ResultSet</code> object as
0242 * a <code>boolean</code> in the Java programming language.
0243 *
0244 * <P>If the designated column has a datatype of CHAR or VARCHAR
0245 * and contains a "0" or has a datatype of BIT, TINYINT, SMALLINT, INTEGER or BIGINT
0246 * and contains a 0, a value of <code>false</code> is returned. If the designated column has a datatype
0247 * of CHAR or VARCHAR
0248 * and contains a "1" or has a datatype of BIT, TINYINT, SMALLINT, INTEGER or BIGINT
0249 * and contains a 1, a value of <code>true</code> is returned.
0250 *
0251 * @param columnIndex the first column is 1, the second is 2, ...
0252 * @return the column value; if the value is SQL <code>NULL</code>, the
0253 * value returned is <code>false</code>
0254 * @exception SQLException if the columnIndex is not valid;
0255 * if a database access error occurs or this method is
0256 * called on a closed result set
0257 */
0258 boolean getBoolean(int columnIndex) throws SQLException;
0259
0260 /**
0261 * Retrieves the value of the designated column in the current row
0262 * of this <code>ResultSet</code> object as
0263 * a <code>byte</code> in the Java programming language.
0264 *
0265 * @param columnIndex the first column is 1, the second is 2, ...
0266 * @return the column value; if the value is SQL <code>NULL</code>, the
0267 * value returned is <code>0</code>
0268 * @exception SQLException if the columnIndex is not valid;
0269 * if a database access error occurs or this method is
0270 * called on a closed result set
0271 */
0272 byte getByte(int columnIndex) throws SQLException;
0273
0274 /**
0275 * Retrieves the value of the designated column in the current row
0276 * of this <code>ResultSet</code> object as
0277 * a <code>short</code> in the Java programming language.
0278 *
0279 * @param columnIndex the first column is 1, the second is 2, ...
0280 * @return the column value; if the value is SQL <code>NULL</code>, the
0281 * value returned is <code>0</code>
0282 * @exception SQLException if the columnIndex is not valid;
0283 * if a database access error occurs or this method is
0284 * called on a closed result set
0285 */
0286 short getShort(int columnIndex) throws SQLException;
0287
0288 /**
0289 * Retrieves the value of the designated column in the current row
0290 * of this <code>ResultSet</code> object as
0291 * an <code>int</code> in the Java programming language.
0292 *
0293 * @param columnIndex the first column is 1, the second is 2, ...
0294 * @return the column value; if the value is SQL <code>NULL</code>, the
0295 * value returned is <code>0</code>
0296 * @exception SQLException if the columnIndex is not valid;
0297 * if a database access error occurs or this method is
0298 * called on a closed result set
0299 */
0300 int getInt(int columnIndex) throws SQLException;
0301
0302 /**
0303 * Retrieves the value of the designated column in the current row
0304 * of this <code>ResultSet</code> object as
0305 * a <code>long</code> in the Java programming language.
0306 *
0307 * @param columnIndex the first column is 1, the second is 2, ...
0308 * @return the column value; if the value is SQL <code>NULL</code>, the
0309 * value returned is <code>0</code>
0310 * @exception SQLException if the columnIndex is not valid;
0311 * if a database access error occurs or this method is
0312 * called on a closed result set
0313 */
0314 long getLong(int columnIndex) throws SQLException;
0315
0316 /**
0317 * Retrieves the value of the designated column in the current row
0318 * of this <code>ResultSet</code> object as
0319 * a <code>float</code> in the Java programming language.
0320 *
0321 * @param columnIndex the first column is 1, the second is 2, ...
0322 * @return the column value; if the value is SQL <code>NULL</code>, the
0323 * value returned is <code>0</code>
0324 * @exception SQLException if the columnIndex is not valid;
0325 * if a database access error occurs or this method is
0326 * called on a closed result set
0327 */
0328 float getFloat(int columnIndex) throws SQLException;
0329
0330 /**
0331 * Retrieves the value of the designated column in the current row
0332 * of this <code>ResultSet</code> object as
0333 * a <code>double</code> in the Java programming language.
0334 *
0335 * @param columnIndex the first column is 1, the second is 2, ...
0336 * @return the column value; if the value is SQL <code>NULL</code>, the
0337 * value returned is <code>0</code>
0338 * @exception SQLException if the columnIndex is not valid;
0339 * if a database access error occurs or this method is
0340 * called on a closed result set
0341 */
0342 double getDouble(int columnIndex) throws SQLException;
0343
0344 /**
0345 * Retrieves the value of the designated column in the current row
0346 * of this <code>ResultSet</code> object as
0347 * a <code>java.sql.BigDecimal</code> in the Java programming language.
0348 *
0349 * @param columnIndex the first column is 1, the second is 2, ...
0350 * @param scale the number of digits to the right of the decimal point
0351 * @return the column value; if the value is SQL <code>NULL</code>, the
0352 * value returned is <code>null</code>
0353 * @exception SQLException if the columnIndex is not valid;
0354 * if a database access error occurs or this method is
0355 * called on a closed result set
0356 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
0357 * this method
0358 * @deprecated
0359 */
0360 BigDecimal getBigDecimal(int columnIndex, int scale)
0361 throws SQLException;
0362
0363 /**
0364 * Retrieves the value of the designated column in the current row
0365 * of this <code>ResultSet</code> object as
0366 * a <code>byte</code> array in the Java programming language.
0367 * The bytes represent the raw values returned by the driver.
0368 *
0369 * @param columnIndex the first column is 1, the second is 2, ...
0370 * @return the column value; if the value is SQL <code>NULL</code>, the
0371 * value returned is <code>null</code>
0372 * @exception SQLException if the columnIndex is not valid;
0373 * if a database access error occurs or this method is
0374 * called on a closed result set
0375 */
0376 byte[] getBytes(int columnIndex) throws SQLException;
0377
0378 /**
0379 * Retrieves the value of the designated column in the current row
0380 * of this <code>ResultSet</code> object as
0381 * a <code>java.sql.Date</code> object in the Java programming language.
0382 *
0383 * @param columnIndex the first column is 1, the second is 2, ...
0384 * @return the column value; if the value is SQL <code>NULL</code>, the
0385 * value returned is <code>null</code>
0386 * @exception SQLException if the columnIndex is not valid;
0387 * if a database access error occurs or this method is
0388 * called on a closed result set
0389 */
0390 java.sql.Date getDate(int columnIndex) throws SQLException;
0391
0392 /**
0393 * Retrieves the value of the designated column in the current row
0394 * of this <code>ResultSet</code> object as
0395 * a <code>java.sql.Time</code> object in the Java programming language.
0396 *
0397 * @param columnIndex the first column is 1, the second is 2, ...
0398 * @return the column value; if the value is SQL <code>NULL</code>, the
0399 * value returned is <code>null</code>
0400 * @exception SQLException if the columnIndex is not valid;
0401 * if a database access error occurs or this method is
0402 * called on a closed result set
0403 */
0404 java.sql.Time getTime(int columnIndex) throws SQLException;
0405
0406 /**
0407 * Retrieves the value of the designated column in the current row
0408 * of this <code>ResultSet</code> object as
0409 * a <code>java.sql.Timestamp</code> object in the Java programming language.
0410 *
0411 * @param columnIndex the first column is 1, the second is 2, ...
0412 * @return the column value; if the value is SQL <code>NULL</code>, the
0413 * value returned is <code>null</code>
0414 * @exception SQLException if the columnIndex is not valid;
0415 * if a database access error occurs or this method is
0416 * called on a closed result set
0417 */
0418 java.sql.Timestamp getTimestamp(int columnIndex)
0419 throws SQLException;
0420
0421 /**
0422 * Retrieves the value of the designated column in the current row
0423 * of this <code>ResultSet</code> object as
0424 * a stream of ASCII characters. The value can then be read in chunks from the
0425 * stream. This method is particularly
0426 * suitable for retrieving large <char>LONGVARCHAR</char> values.
0427 * The JDBC driver will
0428 * do any necessary conversion from the database format into ASCII.
0429 *
0430 * <P><B>Note:</B> All the data in the returned stream must be
0431 * read prior to getting the value of any other column. The next
0432 * call to a getter method implicitly closes the stream. Also, a
0433 * stream may return <code>0</code> when the method
0434 * <code>InputStream.available</code>
0435 * is called whether there is data available or not.
0436 *
0437 * @param columnIndex the first column is 1, the second is 2, ...
0438 * @return a Java input stream that delivers the database column value
0439 * as a stream of one-byte ASCII characters;
0440 * if the value is SQL <code>NULL</code>, the
0441 * value returned is <code>null</code>
0442 * @exception SQLException if the columnIndex is not valid;
0443 * if a database access error occurs or this method is
0444 * called on a closed result set
0445 */
0446 java.io.InputStream getAsciiStream(int columnIndex)
0447 throws SQLException;
0448
0449 /**
0450 * Retrieves the value of the designated column in the current row
0451 * of this <code>ResultSet</code> object as
0452 * as a stream of two-byte 3 characters. The first byte is
0453 * the high byte; the second byte is the low byte.
0454 *
0455 * The value can then be read in chunks from the
0456 * stream. This method is particularly
0457 * suitable for retrieving large <code>LONGVARCHAR</code>values. The
0458 * JDBC driver will do any necessary conversion from the database
0459 * format into Unicode.
0460 *
0461 * <P><B>Note:</B> All the data in the returned stream must be
0462 * read prior to getting the value of any other column. The next
0463 * call to a getter method implicitly closes the stream.
0464 * Also, a stream may return <code>0</code> when the method
0465 * <code>InputStream.available</code>
0466 * is called, whether there is data available or not.
0467 *
0468 * @param columnIndex the first column is 1, the second is 2, ...
0469 * @return a Java input stream that delivers the database column value
0470 * as a stream of two-byte Unicode characters;
0471 * if the value is SQL <code>NULL</code>, the value returned is
0472 * <code>null</code>
0473 *
0474 * @exception SQLException if the columnIndex is not valid;
0475 * if a database access error occurs or this method is
0476 * called on a closed result set
0477 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
0478 * this method
0479 * @deprecated use <code>getCharacterStream</code> in place of
0480 * <code>getUnicodeStream</code>
0481 */
0482 java.io.InputStream getUnicodeStream(int columnIndex)
0483 throws SQLException;
0484
0485 /**
0486 * Retrieves the value of the designated column in the current row
0487 * of this <code>ResultSet</code> object as a stream of
0488 * uninterpreted bytes. The value can then be read in chunks from the
0489 * stream. This method is particularly
0490 * suitable for retrieving large <code>LONGVARBINARY</code> values.
0491 *
0492 * <P><B>Note:</B> All the data in the returned stream must be
0493 * read prior to getting the value of any other column. The next
0494 * call to a getter method implicitly closes the stream. Also, a
0495 * stream may return <code>0</code> when the method
0496 * <code>InputStream.available</code>
0497 * is called whether there is data available or not.
0498 *
0499 * @param columnIndex the first column is 1, the second is 2, ...
0500 * @return a Java input stream that delivers the database column value
0501 * as a stream of uninterpreted bytes;
0502 * if the value is SQL <code>NULL</code>, the value returned is
0503 * <code>null</code>
0504 * @exception SQLException if the columnIndex is not valid;
0505 * if a database access error occurs or this method is
0506 * called on a closed result set
0507 */
0508 java.io.InputStream getBinaryStream(int columnIndex)
0509 throws SQLException;
0510
0511 // Methods for accessing results by column label
0512
0513 /**
0514 * Retrieves the value of the designated column in the current row
0515 * of this <code>ResultSet</code> object as
0516 * a <code>String</code> in the Java programming language.
0517 *
0518 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
0519 * @return the column value; if the value is SQL <code>NULL</code>, the
0520 * value returned is <code>null</code>
0521 * @exception SQLException if the columnLabel is not valid;
0522 * if a database access error occurs or this method is
0523 * called on a closed result set
0524 */
0525 String getString(String columnLabel) throws SQLException;
0526
0527 /**
0528 * Retrieves the value of the designated column in the current row
0529 * of this <code>ResultSet</code> object as
0530 * a <code>boolean</code> in the Java programming language.
0531 *
0532 * <P>If the designated column has a datatype of CHAR or VARCHAR
0533 * and contains a "0" or has a datatype of BIT, TINYINT, SMALLINT, INTEGER or BIGINT
0534 * and contains a 0, a value of <code>false</code> is returned. If the designated column has a datatype
0535 * of CHAR or VARCHAR
0536 * and contains a "1" or has a datatype of BIT, TINYINT, SMALLINT, INTEGER or BIGINT
0537 * and contains a 1, a value of <code>true</code> is returned.
0538 *
0539 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
0540 * @return the column value; if the value is SQL <code>NULL</code>, the
0541 * value returned is <code>false</code>
0542 * @exception SQLException if the columnLabel is not valid;
0543 * if a database access error occurs or this method is
0544 * called on a closed result set
0545 */
0546 boolean getBoolean(String columnLabel) throws SQLException;
0547
0548 /**
0549 * Retrieves the value of the designated column in the current row
0550 * of this <code>ResultSet</code> object as
0551 * a <code>byte</code> in the Java programming language.
0552 *
0553 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
0554 * @return the column value; if the value is SQL <code>NULL</code>, the
0555 * value returned is <code>0</code>
0556 * @exception SQLException if the columnLabel is not valid;
0557 * if a database access error occurs or this method is
0558 * called on a closed result set
0559 */
0560 byte getByte(String columnLabel) throws SQLException;
0561
0562 /**
0563 * Retrieves the value of the designated column in the current row
0564 * of this <code>ResultSet</code> object as
0565 * a <code>short</code> in the Java programming language.
0566 *
0567 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
0568 * @return the column value; if the value is SQL <code>NULL</code>, the
0569 * value returned is <code>0</code>
0570 * @exception SQLException if the columnLabel is not valid;
0571 * if a database access error occurs or this method is
0572 * called on a closed result set
0573 */
0574 short getShort(String columnLabel) throws SQLException;
0575
0576 /**
0577 * Retrieves the value of the designated column in the current row
0578 * of this <code>ResultSet</code> object as
0579 * an <code>int</code> in the Java programming language.
0580 *
0581 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
0582 * @return the column value; if the value is SQL <code>NULL</code>, the
0583 * value returned is <code>0</code>
0584 * @exception SQLException if the columnLabel is not valid;
0585 * if a database access error occurs or this method is
0586 * called on a closed result set
0587 */
0588 int getInt(String columnLabel) throws SQLException;
0589
0590 /**
0591 * Retrieves the value of the designated column in the current row
0592 * of this <code>ResultSet</code> object as
0593 * a <code>long</code> in the Java programming language.
0594 *
0595 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
0596 * @return the column value; if the value is SQL <code>NULL</code>, the
0597 * value returned is <code>0</code>
0598 * @exception SQLException if the columnLabel is not valid;
0599 * if a database access error occurs or this method is
0600 * called on a closed result set
0601 */
0602 long getLong(String columnLabel) throws SQLException;
0603
0604 /**
0605 * Retrieves the value of the designated column in the current row
0606 * of this <code>ResultSet</code> object as
0607 * a <code>float</code> in the Java programming language.
0608 *
0609 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
0610 * @return the column value; if the value is SQL <code>NULL</code>, the
0611 * value returned is <code>0</code>
0612 * @exception SQLException if the columnLabel is not valid;
0613 * if a database access error occurs or this method is
0614 * called on a closed result set
0615 */
0616 float getFloat(String columnLabel) throws SQLException;
0617
0618 /**
0619 * Retrieves the value of the designated column in the current row
0620 * of this <code>ResultSet</code> object as
0621 * a <code>double</code> in the Java programming language.
0622 *
0623 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
0624 * @return the column value; if the value is SQL <code>NULL</code>, the
0625 * value returned is <code>0</code>
0626 * @exception SQLException if the columnLabel is not valid;
0627 * if a database access error occurs or this method is
0628 * called on a closed result set
0629 */
0630 double getDouble(String columnLabel) throws SQLException;
0631
0632 /**
0633 * Retrieves the value of the designated column in the current row
0634 * of this <code>ResultSet</code> object as
0635 * a <code>java.math.BigDecimal</code> in the Java programming language.
0636 *
0637 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
0638 * @param scale the number of digits to the right of the decimal point
0639 * @return the column value; if the value is SQL <code>NULL</code>, the
0640 * value returned is <code>null</code>
0641 * @exception SQLException if the columnLabel is not valid;
0642 * if a database access error occurs or this method is
0643 * called on a closed result set
0644 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
0645 * this method
0646 * @deprecated
0647 */
0648 BigDecimal getBigDecimal(String columnLabel, int scale)
0649 throws SQLException;
0650
0651 /**
0652 * Retrieves the value of the designated column in the current row
0653 * of this <code>ResultSet</code> object as
0654 * a <code>byte</code> array in the Java programming language.
0655 * The bytes represent the raw values returned by the driver.
0656 *
0657 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
0658 * @return the column value; if the value is SQL <code>NULL</code>, the
0659 * value returned is <code>null</code>
0660 * @exception SQLException if the columnLabel is not valid;
0661 * if a database access error occurs or this method is
0662 * called on a closed result set
0663 */
0664 byte[] getBytes(String columnLabel) throws SQLException;
0665
0666 /**
0667 * Retrieves the value of the designated column in the current row
0668 * of this <code>ResultSet</code> object as
0669 * a <code>java.sql.Date</code> object in the Java programming language.
0670 *
0671 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
0672 * @return the column value; if the value is SQL <code>NULL</code>, the
0673 * value returned is <code>null</code>
0674 * @exception SQLException if the columnLabel is not valid;
0675 * if a database access error occurs or this method is
0676 * called on a closed result set
0677 */
0678 java.sql.Date getDate(String columnLabel) throws SQLException;
0679
0680 /**
0681 * Retrieves the value of the designated column in the current row
0682 * of this <code>ResultSet</code> object as
0683 * a <code>java.sql.Time</code> object in the Java programming language.
0684 *
0685 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
0686 * @return the column value;
0687 * if the value is SQL <code>NULL</code>,
0688 * the value returned is <code>null</code>
0689 * @exception SQLException if the columnLabel is not valid;
0690 * if a database access error occurs or this method is
0691 * called on a closed result set
0692 */
0693 java.sql.Time getTime(String columnLabel) throws SQLException;
0694
0695 /**
0696 * Retrieves the value of the designated column in the current row
0697 * of this <code>ResultSet</code> object as
0698 * a <code>java.sql.Timestamp</code> object in the Java programming language.
0699 *
0700 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
0701 * @return the column value; if the value is SQL <code>NULL</code>, the
0702 * value returned is <code>null</code>
0703 * @exception SQLException if the columnLabel is not valid;
0704 * if a database access error occurs or this method is
0705 * called on a closed result set
0706 */
0707 java.sql.Timestamp getTimestamp(String columnLabel)
0708 throws SQLException;
0709
0710 /**
0711 * Retrieves the value of the designated column in the current row
0712 * of this <code>ResultSet</code> object as a stream of
0713 * ASCII characters. The value can then be read in chunks from the
0714 * stream. This method is particularly
0715 * suitable for retrieving large <code>LONGVARCHAR</code> values.
0716 * The JDBC driver will
0717 * do any necessary conversion from the database format into ASCII.
0718 *
0719 * <P><B>Note:</B> All the data in the returned stream must be
0720 * read prior to getting the value of any other column. The next
0721 * call to a getter method implicitly closes the stream. Also, a
0722 * stream may return <code>0</code> when the method <code>available</code>
0723 * is called whether there is data available or not.
0724 *
0725 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
0726 * @return a Java input stream that delivers the database column value
0727 * as a stream of one-byte ASCII characters.
0728 * If the value is SQL <code>NULL</code>,
0729 * the value returned is <code>null</code>.
0730 * @exception SQLException if the columnLabel is not valid;
0731 * if a database access error occurs or this method is
0732 * called on a closed result set
0733 */
0734 java.io.InputStream getAsciiStream(String columnLabel)
0735 throws SQLException;
0736
0737 /**
0738 * Retrieves the value of the designated column in the current row
0739 * of this <code>ResultSet</code> object as a stream of two-byte
0740 * Unicode characters. The first byte is the high byte; the second
0741 * byte is the low byte.
0742 *
0743 * The value can then be read in chunks from the
0744 * stream. This method is particularly
0745 * suitable for retrieving large <code>LONGVARCHAR</code> values.
0746 * The JDBC technology-enabled driver will
0747 * do any necessary conversion from the database format into Unicode.
0748 *
0749 * <P><B>Note:</B> All the data in the returned stream must be
0750 * read prior to getting the value of any other column. The next
0751 * call to a getter method implicitly closes the stream.
0752 * Also, a stream may return <code>0</code> when the method
0753 * <code>InputStream.available</code> is called, whether there
0754 * is data available or not.
0755 *
0756 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
0757 * @return a Java input stream that delivers the database column value
0758 * as a stream of two-byte Unicode characters.
0759 * If the value is SQL <code>NULL</code>, the value returned
0760 * is <code>null</code>.
0761 * @exception SQLException if the columnLabel is not valid;
0762 * if a database access error occurs or this method is
0763 * called on a closed result set
0764 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
0765 * this method
0766 * @deprecated use <code>getCharacterStream</code> instead
0767 */
0768 java.io.InputStream getUnicodeStream(String columnLabel)
0769 throws SQLException;
0770
0771 /**
0772 * Retrieves the value of the designated column in the current row
0773 * of this <code>ResultSet</code> object as a stream of uninterpreted
0774 * <code>byte</code>s.
0775 * The value can then be read in chunks from the
0776 * stream. This method is particularly
0777 * suitable for retrieving large <code>LONGVARBINARY</code>
0778 * values.
0779 *
0780 * <P><B>Note:</B> All the data in the returned stream must be
0781 * read prior to getting the value of any other column. The next
0782 * call to a getter method implicitly closes the stream. Also, a
0783 * stream may return <code>0</code> when the method <code>available</code>
0784 * is called whether there is data available or not.
0785 *
0786 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
0787 * @return a Java input stream that delivers the database column value
0788 * as a stream of uninterpreted bytes;
0789 * if the value is SQL <code>NULL</code>, the result is <code>null</code>
0790 * @exception SQLException if the columnLabel is not valid;
0791 * if a database access error occurs or this method is
0792 * called on a closed result set
0793 */
0794 java.io.InputStream getBinaryStream(String columnLabel)
0795 throws SQLException;
0796
0797 // Advanced features:
0798
0799 /**
0800 * Retrieves the first warning reported by calls on this
0801 * <code>ResultSet</code> object.
0802 * Subsequent warnings on this <code>ResultSet</code> object
0803 * will be chained to the <code>SQLWarning</code> object that
0804 * this method returns.
0805 *
0806 * <P>The warning chain is automatically cleared each time a new
0807 * row is read. This method may not be called on a <code>ResultSet</code>
0808 * object that has been closed; doing so will cause an
0809 * <code>SQLException</code> to be thrown.
0810 * <P>
0811 * <B>Note:</B> This warning chain only covers warnings caused
0812 * by <code>ResultSet</code> methods. Any warning caused by
0813 * <code>Statement</code> methods
0814 * (such as reading OUT parameters) will be chained on the
0815 * <code>Statement</code> object.
0816 *
0817 * @return the first <code>SQLWarning</code> object reported or
0818 * <code>null</code> if there are none
0819 * @exception SQLException if a database access error occurs or this method is
0820 * called on a closed result set
0821 */
0822 SQLWarning getWarnings() throws SQLException;
0823
0824 /**
0825 * Clears all warnings reported on this <code>ResultSet</code> object.
0826 * After this method is called, the method <code>getWarnings</code>
0827 * returns <code>null</code> until a new warning is
0828 * reported for this <code>ResultSet</code> object.
0829 *
0830 * @exception SQLException if a database access error occurs or this method is
0831 * called on a closed result set
0832 */
0833 void clearWarnings() throws SQLException;
0834
0835 /**
0836 * Retrieves the name of the SQL cursor used by this <code>ResultSet</code>
0837 * object.
0838 *
0839 * <P>In SQL, a result table is retrieved through a cursor that is
0840 * named. The current row of a result set can be updated or deleted
0841 * using a positioned update/delete statement that references the
0842 * cursor name. To insure that the cursor has the proper isolation
0843 * level to support update, the cursor's <code>SELECT</code> statement
0844 * should be of the form <code>SELECT FOR UPDATE</code>. If
0845 * <code>FOR UPDATE</code> is omitted, the positioned updates may fail.
0846 *
0847 * <P>The JDBC API supports this SQL feature by providing the name of the
0848 * SQL cursor used by a <code>ResultSet</code> object.
0849 * The current row of a <code>ResultSet</code> object
0850 * is also the current row of this SQL cursor.
0851 *
0852 * @return the SQL name for this <code>ResultSet</code> object's cursor
0853 * @exception SQLException if a database access error occurs or this method is called on a closed result set
0854 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
0855 * this method
0856 */
0857 String getCursorName() throws SQLException;
0858
0859 /**
0860 * Retrieves the number, types and properties of
0861 * this <code>ResultSet</code> object's columns.
0862 *
0863 * @return the description of this <code>ResultSet</code> object's columns
0864 * @exception SQLException if a database access error occurs or this method is
0865 * called on a closed result set
0866 */
0867 ResultSetMetaData getMetaData() throws SQLException;
0868
0869 /**
0870 * <p>Gets the value of the designated column in the current row
0871 * of this <code>ResultSet</code> object as
0872 * an <code>Object</code> in the Java programming language.
0873 *
0874 * <p>This method will return the value of the given column as a
0875 * Java object. The type of the Java object will be the default
0876 * Java object type corresponding to the column's SQL type,
0877 * following the mapping for built-in types specified in the JDBC
0878 * specification. If the value is an SQL <code>NULL</code>,
0879 * the driver returns a Java <code>null</code>.
0880 *
0881 * <p>This method may also be used to read database-specific
0882 * abstract data types.
0883 *
0884 * In the JDBC 2.0 API, the behavior of method
0885 * <code>getObject</code> is extended to materialize
0886 * data of SQL user-defined types.
0887 * <p>
0888 * If <code>Connection.getTypeMap</code> does not throw a
0889 * <code>SQLFeatureNotSupportedException</code>,
0890 * then when a column contains a structured or distinct value,
0891 * the behavior of this method is as
0892 * if it were a call to: <code>getObject(columnIndex,
0893 * this.getStatement().getConnection().getTypeMap())</code>.
0894 *
0895 * If <code>Connection.getTypeMap</code> does throw a
0896 * <code>SQLFeatureNotSupportedException</code>,
0897 * then structured values are not supported, and distinct values
0898 * are mapped to the default Java class as determined by the
0899 * underlying SQL type of the DISTINCT type.
0900 *
0901 * @param columnIndex the first column is 1, the second is 2, ...
0902 * @return a <code>java.lang.Object</code> holding the column value
0903 * @exception SQLException if the columnIndex is not valid;
0904 * if a database access error occurs or this method is
0905 * called on a closed result set
0906 */
0907 Object getObject(int columnIndex) throws SQLException;
0908
0909 /**
0910 * <p>Gets the value of the designated column in the current row
0911 * of this <code>ResultSet</code> object as
0912 * an <code>Object</code> in the Java programming language.
0913 *
0914 * <p>This method will return the value of the given column as a
0915 * Java object. The type of the Java object will be the default
0916 * Java object type corresponding to the column's SQL type,
0917 * following the mapping for built-in types specified in the JDBC
0918 * specification. If the value is an SQL <code>NULL</code>,
0919 * the driver returns a Java <code>null</code>.
0920 * <P>
0921 * This method may also be used to read database-specific
0922 * abstract data types.
0923 * <P>
0924 * In the JDBC 2.0 API, the behavior of the method
0925 * <code>getObject</code> is extended to materialize
0926 * data of SQL user-defined types. When a column contains
0927 * a structured or distinct value, the behavior of this method is as
0928 * if it were a call to: <code>getObject(columnIndex,
0929 * this.getStatement().getConnection().getTypeMap())</code>.
0930 *
0931 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
0932 * @return a <code>java.lang.Object</code> holding the column value
0933 * @exception SQLException if the columnLabel is not valid;
0934 * if a database access error occurs or this method is
0935 * called on a closed result set
0936 */
0937 Object getObject(String columnLabel) throws SQLException;
0938
0939 //----------------------------------------------------------------
0940
0941 /**
0942 * Maps the given <code>ResultSet</code> column label to its
0943 * <code>ResultSet</code> column index.
0944 *
0945 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
0946 * @return the column index of the given column name
0947 * @exception SQLException if the <code>ResultSet</code> object
0948 * does not contain a column labeled <code>columnLabel</code>, a database access error occurs
0949 * or this method is called on a closed result set
0950 */
0951 int findColumn(String columnLabel) throws SQLException;
0952
0953 //--------------------------JDBC 2.0-----------------------------------
0954
0955 //---------------------------------------------------------------------
0956 // Getters and Setters
0957 //---------------------------------------------------------------------
0958
0959 /**
0960 * Retrieves the value of the designated column in the current row
0961 * of this <code>ResultSet</code> object as a
0962 * <code>java.io.Reader</code> object.
0963 * @return a <code>java.io.Reader</code> object that contains the column
0964 * value; if the value is SQL <code>NULL</code>, the value returned is
0965 * <code>null</code> in the Java programming language.
0966 * @param columnIndex the first column is 1, the second is 2, ...
0967 * @exception SQLException if the columnIndex is not valid;
0968 * if a database access error occurs or this method is
0969 * called on a closed result set
0970 * @since 1.2
0971 */
0972 java.io.Reader getCharacterStream(int columnIndex)
0973 throws SQLException;
0974
0975 /**
0976 * Retrieves the value of the designated column in the current row
0977 * of this <code>ResultSet</code> object as a
0978 * <code>java.io.Reader</code> object.
0979 *
0980 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
0981 * @return a <code>java.io.Reader</code> object that contains the column
0982 * value; if the value is SQL <code>NULL</code>, the value returned is
0983 * <code>null</code> in the Java programming language
0984 * @exception SQLException if the columnLabel is not valid;
0985 * if a database access error occurs or this method is
0986 * called on a closed result set
0987 * @since 1.2
0988 */
0989 java.io.Reader getCharacterStream(String columnLabel)
0990 throws SQLException;
0991
0992 /**
0993 * Retrieves the value of the designated column in the current row
0994 * of this <code>ResultSet</code> object as a
0995 * <code>java.math.BigDecimal</code> with full precision.
0996 *
0997 * @param columnIndex the first column is 1, the second is 2, ...
0998 * @return the column value (full precision);
0999 * if the value is SQL <code>NULL</code>, the value returned is
1000 * <code>null</code> in the Java programming language.
1001 * @exception SQLException if the columnIndex is not valid;
1002 * if a database access error occurs or this method is
1003 * called on a closed result set
1004 * @since 1.2
1005 */
1006 BigDecimal getBigDecimal(int columnIndex) throws SQLException;
1007
1008 /**
1009 * Retrieves the value of the designated column in the current row
1010 * of this <code>ResultSet</code> object as a
1011 * <code>java.math.BigDecimal</code> with full precision.
1012 *
1013 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
1014 * @return the column value (full precision);
1015 * if the value is SQL <code>NULL</code>, the value returned is
1016 * <code>null</code> in the Java programming language.
1017 * @exception SQLException if the columnLabel is not valid;
1018 * if a database access error occurs or this method is
1019 * called on a closed result set
1020 * @since 1.2
1021 *
1022 */
1023 BigDecimal getBigDecimal(String columnLabel) throws SQLException;
1024
1025 //---------------------------------------------------------------------
1026 // Traversal/Positioning
1027 //---------------------------------------------------------------------
1028
1029 /**
1030 * Retrieves whether the cursor is before the first row in
1031 * this <code>ResultSet</code> object.
1032 * <p>
1033 * <strong>Note:</strong>Support for the <code>isBeforeFirst</code> method
1034 * is optional for <code>ResultSet</code>s with a result
1035 * set type of <code>TYPE_FORWARD_ONLY</code>
1036 *
1037 * @return <code>true</code> if the cursor is before the first row;
1038 * <code>false</code> if the cursor is at any other position or the
1039 * result set contains no rows
1040 * @exception SQLException if a database access error occurs or this method is
1041 * called on a closed result set
1042 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1043 * this method
1044 * @since 1.2
1045 */
1046 boolean isBeforeFirst() throws SQLException;
1047
1048 /**
1049 * Retrieves whether the cursor is after the last row in
1050 * this <code>ResultSet</code> object.
1051 * <p>
1052 * <strong>Note:</strong>Support for the <code>isAfterLast</code> method
1053 * is optional for <code>ResultSet</code>s with a result
1054 * set type of <code>TYPE_FORWARD_ONLY</code>
1055 *
1056 * @return <code>true</code> if the cursor is after the last row;
1057 * <code>false</code> if the cursor is at any other position or the
1058 * result set contains no rows
1059 * @exception SQLException if a database access error occurs or this method is
1060 * called on a closed result set
1061 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1062 * this method
1063 * @since 1.2
1064 */
1065 boolean isAfterLast() throws SQLException;
1066
1067 /**
1068 * Retrieves whether the cursor is on the first row of
1069 * this <code>ResultSet</code> object.
1070 * <p>
1071 * <strong>Note:</strong>Support for the <code>isFirst</code> method
1072 * is optional for <code>ResultSet</code>s with a result
1073 * set type of <code>TYPE_FORWARD_ONLY</code>
1074 *
1075 * @return <code>true</code> if the cursor is on the first row;
1076 * <code>false</code> otherwise
1077 * @exception SQLException if a database access error occurs or this method is
1078 * called on a closed result set
1079 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1080 * this method
1081 * @since 1.2
1082 */
1083 boolean isFirst() throws SQLException;
1084
1085 /**
1086 * Retrieves whether the cursor is on the last row of
1087 * this <code>ResultSet</code> object.
1088 * <strong>Note:</strong> Calling the method <code>isLast</code> may be expensive
1089 * because the JDBC driver
1090 * might need to fetch ahead one row in order to determine
1091 * whether the current row is the last row in the result set.
1092 * <p>
1093 * <strong>Note:</strong> Support for the <code>isLast</code> method
1094 * is optional for <code>ResultSet</code>s with a result
1095 * set type of <code>TYPE_FORWARD_ONLY</code>
1096 * @return <code>true</code> if the cursor is on the last row;
1097 * <code>false</code> otherwise
1098 * @exception SQLException if a database access error occurs or this method is
1099 * called on a closed result set
1100 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1101 * this method
1102 * @since 1.2
1103 */
1104 boolean isLast() throws SQLException;
1105
1106 /**
1107 * Moves the cursor to the front of
1108 * this <code>ResultSet</code> object, just before the
1109 * first row. This method has no effect if the result set contains no rows.
1110 *
1111 * @exception SQLException if a database access error
1112 * occurs; this method is called on a closed result set or the
1113 * result set type is <code>TYPE_FORWARD_ONLY</code>
1114 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1115 * this method
1116 * @since 1.2
1117 */
1118 void beforeFirst() throws SQLException;
1119
1120 /**
1121 * Moves the cursor to the end of
1122 * this <code>ResultSet</code> object, just after the
1123 * last row. This method has no effect if the result set contains no rows.
1124 * @exception SQLException if a database access error
1125 * occurs; this method is called on a closed result set
1126 * or the result set type is <code>TYPE_FORWARD_ONLY</code>
1127 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1128 * this method
1129 * @since 1.2
1130 */
1131 void afterLast() throws SQLException;
1132
1133 /**
1134 * Moves the cursor to the first row in
1135 * this <code>ResultSet</code> object.
1136 *
1137 * @return <code>true</code> if the cursor is on a valid row;
1138 * <code>false</code> if there are no rows in the result set
1139 * @exception SQLException if a database access error
1140 * occurs; this method is called on a closed result set
1141 * or the result set type is <code>TYPE_FORWARD_ONLY</code>
1142 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1143 * this method
1144 * @since 1.2
1145 */
1146 boolean first() throws SQLException;
1147
1148 /**
1149 * Moves the cursor to the last row in
1150 * this <code>ResultSet</code> object.
1151 *
1152 * @return <code>true</code> if the cursor is on a valid row;
1153 * <code>false</code> if there are no rows in the result set
1154 * @exception SQLException if a database access error
1155 * occurs; this method is called on a closed result set
1156 * or the result set type is <code>TYPE_FORWARD_ONLY</code>
1157 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1158 * this method
1159 * @since 1.2
1160 */
1161 boolean last() throws SQLException;
1162
1163 /**
1164 * Retrieves the current row number. The first row is number 1, the
1165 * second number 2, and so on.
1166 * <p>
1167 * <strong>Note:</strong>Support for the <code>getRow</code> method
1168 * is optional for <code>ResultSet</code>s with a result
1169 * set type of <code>TYPE_FORWARD_ONLY</code>
1170 *
1171 * @return the current row number; <code>0</code> if there is no current row
1172 * @exception SQLException if a database access error occurs
1173 * or this method is called on a closed result set
1174 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1175 * this method
1176 * @since 1.2
1177 */
1178 int getRow() throws SQLException;
1179
1180 /**
1181 * Moves the cursor to the given row number in
1182 * this <code>ResultSet</code> object.
1183 *
1184 * <p>If the row number is positive, the cursor moves to
1185 * the given row number with respect to the
1186 * beginning of the result set. The first row is row 1, the second
1187 * is row 2, and so on.
1188 *
1189 * <p>If the given row number is negative, the cursor moves to
1190 * an absolute row position with respect to
1191 * the end of the result set. For example, calling the method
1192 * <code>absolute(-1)</code> positions the
1193 * cursor on the last row; calling the method <code>absolute(-2)</code>
1194 * moves the cursor to the next-to-last row, and so on.
1195 *
1196 * <p>An attempt to position the cursor beyond the first/last row in
1197 * the result set leaves the cursor before the first row or after
1198 * the last row.
1199 *
1200 * <p><B>Note:</B> Calling <code>absolute(1)</code> is the same
1201 * as calling <code>first()</code>. Calling <code>absolute(-1)</code>
1202 * is the same as calling <code>last()</code>.
1203 *
1204 * @param row the number of the row to which the cursor should move.
1205 * A positive number indicates the row number counting from the
1206 * beginning of the result set; a negative number indicates the
1207 * row number counting from the end of the result set
1208 * @return <code>true</code> if the cursor is moved to a position in this
1209 * <code>ResultSet</code> object;
1210 * <code>false</code> if the cursor is before the first row or after the
1211 * last row
1212 * @exception SQLException if a database access error
1213 * occurs; this method is called on a closed result set
1214 * or the result set type is <code>TYPE_FORWARD_ONLY</code>
1215 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1216 * this method
1217 * @since 1.2
1218 */
1219 boolean absolute(int row) throws SQLException;
1220
1221 /**
1222 * Moves the cursor a relative number of rows, either positive or negative.
1223 * Attempting to move beyond the first/last row in the
1224 * result set positions the cursor before/after the
1225 * the first/last row. Calling <code>relative(0)</code> is valid, but does
1226 * not change the cursor position.
1227 *
1228 * <p>Note: Calling the method <code>relative(1)</code>
1229 * is identical to calling the method <code>next()</code> and
1230 * calling the method <code>relative(-1)</code> is identical
1231 * to calling the method <code>previous()</code>.
1232 *
1233 * @param rows an <code>int</code> specifying the number of rows to
1234 * move from the current row; a positive number moves the cursor
1235 * forward; a negative number moves the cursor backward
1236 * @return <code>true</code> if the cursor is on a row;
1237 * <code>false</code> otherwise
1238 * @exception SQLException if a database access error occurs; this method
1239 * is called on a closed result set or the result set type is
1240 * <code>TYPE_FORWARD_ONLY</code>
1241 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1242 * this method
1243 * @since 1.2
1244 */
1245 boolean relative(int rows) throws SQLException;
1246
1247 /**
1248 * Moves the cursor to the previous row in this
1249 * <code>ResultSet</code> object.
1250 *<p>
1251 * When a call to the <code>previous</code> method returns <code>false</code>,
1252 * the cursor is positioned before the first row. Any invocation of a
1253 * <code>ResultSet</code> method which requires a current row will result in a
1254 * <code>SQLException</code> being thrown.
1255 *<p>
1256 * If an input stream is open for the current row, a call to the method
1257 * <code>previous</code> will implicitly close it. A <code>ResultSet</code>
1258 * object's warning change is cleared when a new row is read.
1259 *<p>
1260 *
1261 * @return <code>true</code> if the cursor is now positioned on a valid row;
1262 * <code>false</code> if the cursor is positioned before the first row
1263 * @exception SQLException if a database access error
1264 * occurs; this method is called on a closed result set
1265 * or the result set type is <code>TYPE_FORWARD_ONLY</code>
1266 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1267 * this method
1268 * @since 1.2
1269 */
1270 boolean previous() throws SQLException;
1271
1272 //---------------------------------------------------------------------
1273 // Properties
1274 //---------------------------------------------------------------------
1275
1276 /**
1277 * The constant indicating that the rows in a result set will be
1278 * processed in a forward direction; first-to-last.
1279 * This constant is used by the method <code>setFetchDirection</code>
1280 * as a hint to the driver, which the driver may ignore.
1281 * @since 1.2
1282 */
1283 int FETCH_FORWARD = 1000;
1284
1285 /**
1286 * The constant indicating that the rows in a result set will be
1287 * processed in a reverse direction; last-to-first.
1288 * This constant is used by the method <code>setFetchDirection</code>
1289 * as a hint to the driver, which the driver may ignore.
1290 * @since 1.2
1291 */
1292 int FETCH_REVERSE = 1001;
1293
1294 /**
1295 * The constant indicating that the order in which rows in a
1296 * result set will be processed is unknown.
1297 * This constant is used by the method <code>setFetchDirection</code>
1298 * as a hint to the driver, which the driver may ignore.
1299 */
1300 int FETCH_UNKNOWN = 1002;
1301
1302 /**
1303 * Gives a hint as to the direction in which the rows in this
1304 * <code>ResultSet</code> object will be processed.
1305 * The initial value is determined by the
1306 * <code>Statement</code> object
1307 * that produced this <code>ResultSet</code> object.
1308 * The fetch direction may be changed at any time.
1309 *
1310 * @param direction an <code>int</code> specifying the suggested
1311 * fetch direction; one of <code>ResultSet.FETCH_FORWARD</code>,
1312 * <code>ResultSet.FETCH_REVERSE</code>, or
1313 * <code>ResultSet.FETCH_UNKNOWN</code>
1314 * @exception SQLException if a database access error occurs; this
1315 * method is called on a closed result set or
1316 * the result set type is <code>TYPE_FORWARD_ONLY</code> and the fetch
1317 * direction is not <code>FETCH_FORWARD</code>
1318 * @since 1.2
1319 * @see Statement#setFetchDirection
1320 * @see #getFetchDirection
1321 */
1322 void setFetchDirection(int direction) throws SQLException;
1323
1324 /**
1325 * Retrieves the fetch direction for this
1326 * <code>ResultSet</code> object.
1327 *
1328 * @return the current fetch direction for this <code>ResultSet</code> object
1329 * @exception SQLException if a database access error occurs
1330 * or this method is called on a closed result set
1331 * @since 1.2
1332 * @see #setFetchDirection
1333 */
1334 int getFetchDirection() throws SQLException;
1335
1336 /**
1337 * Gives the JDBC driver a hint as to the number of rows that should
1338 * be fetched from the database when more rows are needed for this
1339 * <code>ResultSet</code> object.
1340 * If the fetch size specified is zero, the JDBC driver
1341 * ignores the value and is free to make its own best guess as to what
1342 * the fetch size should be. The default value is set by the
1343 * <code>Statement</code> object
1344 * that created the result set. The fetch size may be changed at any time.
1345 *
1346 * @param rows the number of rows to fetch
1347 * @exception SQLException if a database access error occurs; this method
1348 * is called on a closed result set or the
1349 * condition <code>rows >= 0 </code> is not satisfied
1350 * @since 1.2
1351 * @see #getFetchSize
1352 */
1353 void setFetchSize(int rows) throws SQLException;
1354
1355 /**
1356 * Retrieves the fetch size for this
1357 * <code>ResultSet</code> object.
1358 *
1359 * @return the current fetch size for this <code>ResultSet</code> object
1360 * @exception SQLException if a database access error occurs
1361 * or this method is called on a closed result set
1362 * @since 1.2
1363 * @see #setFetchSize
1364 */
1365 int getFetchSize() throws SQLException;
1366
1367 /**
1368 * The constant indicating the type for a <code>ResultSet</code> object
1369 * whose cursor may move only forward.
1370 * @since 1.2
1371 */
1372 int TYPE_FORWARD_ONLY = 1003;
1373
1374 /**
1375 * The constant indicating the type for a <code>ResultSet</code> object
1376 * that is scrollable but generally not sensitive to changes to the data
1377 * that underlies the <code>ResultSet</code>.
1378 * @since 1.2
1379 */
1380 int TYPE_SCROLL_INSENSITIVE = 1004;
1381
1382 /**
1383 * The constant indicating the type for a <code>ResultSet</code> object
1384 * that is scrollable and generally sensitive to changes to the data
1385 * that underlies the <code>ResultSet</code>.
1386 * @since 1.2
1387 */
1388 int TYPE_SCROLL_SENSITIVE = 1005;
1389
1390 /**
1391 * Retrieves the type of this <code>ResultSet</code> object.
1392 * The type is determined by the <code>Statement</code> object
1393 * that created the result set.
1394 *
1395 * @return <code>ResultSet.TYPE_FORWARD_ONLY</code>,
1396 * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>,
1397 * or <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
1398 * @exception SQLException if a database access error occurs
1399 * or this method is called on a closed result set
1400 * @since 1.2
1401 */
1402 int getType() throws SQLException;
1403
1404 /**
1405 * The constant indicating the concurrency mode for a
1406 * <code>ResultSet</code> object that may NOT be updated.
1407 * @since 1.2
1408 */
1409 int CONCUR_READ_ONLY = 1007;
1410
1411 /**
1412 * The constant indicating the concurrency mode for a
1413 * <code>ResultSet</code> object that may be updated.
1414 * @since 1.2
1415 */
1416 int CONCUR_UPDATABLE = 1008;
1417
1418 /**
1419 * Retrieves the concurrency mode of this <code>ResultSet</code> object.
1420 * The concurrency used is determined by the
1421 * <code>Statement</code> object that created the result set.
1422 *
1423 * @return the concurrency type, either
1424 * <code>ResultSet.CONCUR_READ_ONLY</code>
1425 * or <code>ResultSet.CONCUR_UPDATABLE</code>
1426 * @exception SQLException if a database access error occurs
1427 * or this method is called on a closed result set
1428 * @since 1.2
1429 */
1430 int getConcurrency() throws SQLException;
1431
1432 //---------------------------------------------------------------------
1433 // Updates
1434 //---------------------------------------------------------------------
1435
1436 /**
1437 * Retrieves whether the current row has been updated. The value returned
1438 * depends on whether or not the result set can detect updates.
1439 * <p>
1440 * <strong>Note:</strong> Support for the <code>rowUpdated</code> method is optional with a result set
1441 * concurrency of <code>CONCUR_READ_ONLY</code>
1442 * @return <code>true</code> if the current row is detected to
1443 * have been visibly updated by the owner or another; <code>false</code> otherwise
1444 * @exception SQLException if a database access error occurs
1445 * or this method is called on a closed result set
1446 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1447 * this method
1448 * @see DatabaseMetaData#updatesAreDetected
1449 * @since 1.2
1450 */
1451 boolean rowUpdated() throws SQLException;
1452
1453 /**
1454 * Retrieves whether the current row has had an insertion.
1455 * The value returned depends on whether or not this
1456 * <code>ResultSet</code> object can detect visible inserts.
1457 * <p>
1458 * <strong>Note:</strong> Support for the <code>rowInserted</code> method is optional with a result set
1459 * concurrency of <code>CONCUR_READ_ONLY</code>
1460 * @return <code>true</code> if the current row is detected to
1461 * have been inserted; <code>false</code> otherwise
1462 * @exception SQLException if a database access error occurs
1463 * or this method is called on a closed result set
1464 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1465 * this method
1466 *
1467 * @see DatabaseMetaData#insertsAreDetected
1468 * @since 1.2
1469 */
1470 boolean rowInserted() throws SQLException;
1471
1472 /**
1473 * Retrieves whether a row has been deleted. A deleted row may leave
1474 * a visible "hole" in a result set. This method can be used to
1475 * detect holes in a result set. The value returned depends on whether
1476 * or not this <code>ResultSet</code> object can detect deletions.
1477 * <p>
1478 * <strong>Note:</strong> Support for the <code>rowDeleted</code> method is optional with a result set
1479 * concurrency of <code>CONCUR_READ_ONLY</code>
1480 * @return <code>true</code> if the current row is detected to
1481 * have been deleted by the owner or another; <code>false</code> otherwise
1482 * @exception SQLException if a database access error occurs
1483 * or this method is called on a closed result set
1484 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1485 * this method
1486 *
1487 * @see DatabaseMetaData#deletesAreDetected
1488 * @since 1.2
1489 */
1490 boolean rowDeleted() throws SQLException;
1491
1492 /**
1493 * Updates the designated column with a <code>null</code> value.
1494 *
1495 * The updater methods are used to update column values in the
1496 * current row or the insert row. The updater methods do not
1497 * update the underlying database; instead the <code>updateRow</code>
1498 * or <code>insertRow</code> methods are called to update the database.
1499 *
1500 * @param columnIndex the first column is 1, the second is 2, ...
1501 * @exception SQLException if the columnIndex is not valid;
1502 * if a database access error occurs;
1503 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1504 * or this method is called on a closed result set
1505 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1506 * this method
1507 * @since 1.2
1508 */
1509 void updateNull(int columnIndex) throws SQLException;
1510
1511 /**
1512 * Updates the designated column with a <code>boolean</code> value.
1513 * The updater methods are used to update column values in the
1514 * current row or the insert row. The updater methods do not
1515 * update the underlying database; instead the <code>updateRow</code> or
1516 * <code>insertRow</code> methods are called to update the database.
1517 *
1518 * @param columnIndex the first column is 1, the second is 2, ...
1519 * @param x the new column value
1520 * @exception SQLException if the columnIndex is not valid;
1521 * if a database access error occurs;
1522 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1523 * or this method is called on a closed result set
1524 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1525 * this method
1526 * @since 1.2
1527 */
1528 void updateBoolean(int columnIndex, boolean x) throws SQLException;
1529
1530 /**
1531 * Updates the designated column with a <code>byte</code> value.
1532 * The updater methods are used to update column values in the
1533 * current row or the insert row. The updater methods do not
1534 * update the underlying database; instead the <code>updateRow</code> or
1535 * <code>insertRow</code> methods are called to update the database.
1536 *
1537 *
1538 * @param columnIndex the first column is 1, the second is 2, ...
1539 * @param x the new column value
1540 * @exception SQLException if the columnIndex is not valid;
1541 * if a database access error occurs;
1542 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1543 * or this method is called on a closed result set
1544 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1545 * this method
1546 * @since 1.2
1547 */
1548 void updateByte(int columnIndex, byte x) throws SQLException;
1549
1550 /**
1551 * Updates the designated column with a <code>short</code> value.
1552 * The updater methods are used to update column values in the
1553 * current row or the insert row. The updater methods do not
1554 * update the underlying database; instead the <code>updateRow</code> or
1555 * <code>insertRow</code> methods are called to update the database.
1556 *
1557 * @param columnIndex the first column is 1, the second is 2, ...
1558 * @param x the new column value
1559 * @exception SQLException if the columnIndex is not valid;
1560 * if a database access error occurs;
1561 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1562 * or this method is called on a closed result set
1563 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1564 * this method
1565 * @since 1.2
1566 */
1567 void updateShort(int columnIndex, short x) throws SQLException;
1568
1569 /**
1570 * Updates the designated column with an <code>int</code> value.
1571 * The updater methods are used to update column values in the
1572 * current row or the insert row. The updater methods do not
1573 * update the underlying database; instead the <code>updateRow</code> or
1574 * <code>insertRow</code> methods are called to update the database.
1575 *
1576 * @param columnIndex the first column is 1, the second is 2, ...
1577 * @param x the new column value
1578 * @exception SQLException if the columnIndex is not valid;
1579 * if a database access error occurs;
1580 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1581 * or this method is called on a closed result set
1582 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1583 * this method
1584 * @since 1.2
1585 */
1586 void updateInt(int columnIndex, int x) throws SQLException;
1587
1588 /**
1589 * Updates the designated column with a <code>long</code> value.
1590 * The updater methods are used to update column values in the
1591 * current row or the insert row. The updater methods do not
1592 * update the underlying database; instead the <code>updateRow</code> or
1593 * <code>insertRow</code> methods are called to update the database.
1594 *
1595 * @param columnIndex the first column is 1, the second is 2, ...
1596 * @param x the new column value
1597 * @exception SQLException if the columnIndex is not valid;
1598 * if a database access error occurs;
1599 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1600 * or this method is called on a closed result set
1601 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1602 * this method
1603 * @since 1.2
1604 */
1605 void updateLong(int columnIndex, long x) throws SQLException;
1606
1607 /**
1608 * Updates the designated column with a <code>float</code> value.
1609 * The updater methods are used to update column values in the
1610 * current row or the insert row. The updater methods do not
1611 * update the underlying database; instead the <code>updateRow</code> or
1612 * <code>insertRow</code> methods are called to update the database.
1613 *
1614 * @param columnIndex the first column is 1, the second is 2, ...
1615 * @param x the new column value
1616 * @exception SQLException if the columnIndex is not valid;
1617 * if a database access error occurs;
1618 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1619 * or this method is called on a closed result set
1620 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1621 * this method
1622 * @since 1.2
1623 */
1624 void updateFloat(int columnIndex, float x) throws SQLException;
1625
1626 /**
1627 * Updates the designated column with a <code>double</code> value.
1628 * The updater methods are used to update column values in the
1629 * current row or the insert row. The updater methods do not
1630 * update the underlying database; instead the <code>updateRow</code> or
1631 * <code>insertRow</code> methods are called to update the database.
1632 *
1633 * @param columnIndex the first column is 1, the second is 2, ...
1634 * @param x the new column value
1635 * @exception SQLException if the columnIndex is not valid;
1636 * if a database access error occurs;
1637 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1638 * or this method is called on a closed result set
1639 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1640 * this method
1641 * @since 1.2
1642 */
1643 void updateDouble(int columnIndex, double x) throws SQLException;
1644
1645 /**
1646 * Updates the designated column with a <code>java.math.BigDecimal</code>
1647 * value.
1648 * The updater methods are used to update column values in the
1649 * current row or the insert row. The updater methods do not
1650 * update the underlying database; instead the <code>updateRow</code> or
1651 * <code>insertRow</code> methods are called to update the database.
1652 *
1653 * @param columnIndex the first column is 1, the second is 2, ...
1654 * @param x the new column value
1655 * @exception SQLException if the columnIndex is not valid;
1656 * if a database access error occurs;
1657 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1658 * or this method is called on a closed result set
1659 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1660 * this method
1661 * @since 1.2
1662 */
1663 void updateBigDecimal(int columnIndex, BigDecimal x)
1664 throws SQLException;
1665
1666 /**
1667 * Updates the designated column with a <code>String</code> value.
1668 * The updater methods are used to update column values in the
1669 * current row or the insert row. The updater methods do not
1670 * update the underlying database; instead the <code>updateRow</code> or
1671 * <code>insertRow</code> methods are called to update the database.
1672 *
1673 * @param columnIndex the first column is 1, the second is 2, ...
1674 * @param x the new column value
1675 * @exception SQLException if the columnIndex is not valid;
1676 * if a database access error occurs;
1677 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1678 * or this method is called on a closed result set
1679 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1680 * this method
1681 * @since 1.2
1682 */
1683 void updateString(int columnIndex, String x) throws SQLException;
1684
1685 /**
1686 * Updates the designated column with a <code>byte</code> array value.
1687 * The updater methods are used to update column values in the
1688 * current row or the insert row. The updater methods do not
1689 * update the underlying database; instead the <code>updateRow</code> or
1690 * <code>insertRow</code> methods are called to update the database.
1691 *
1692 * @param columnIndex the first column is 1, the second is 2, ...
1693 * @param x the new column value
1694 * @exception SQLException if the columnIndex is not valid;
1695 * if a database access error occurs;
1696 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1697 * or this method is called on a closed result set
1698 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1699 * this method
1700 * @since 1.2
1701 */
1702 void updateBytes(int columnIndex, byte x[]) throws SQLException;
1703
1704 /**
1705 * Updates the designated column with a <code>java.sql.Date</code> value.
1706 * The updater methods are used to update column values in the
1707 * current row or the insert row. The updater methods do not
1708 * update the underlying database; instead the <code>updateRow</code> or
1709 * <code>insertRow</code> methods are called to update the database.
1710 *
1711 * @param columnIndex the first column is 1, the second is 2, ...
1712 * @param x the new column value
1713 * @exception SQLException if the columnIndex is not valid;
1714 * if a database access error occurs;
1715 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1716 * or this method is called on a closed result set
1717 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1718 * this method
1719 * @since 1.2
1720 */
1721 void updateDate(int columnIndex, java.sql.Date x)
1722 throws SQLException;
1723
1724 /**
1725 * Updates the designated column with a <code>java.sql.Time</code> value.
1726 * The updater methods are used to update column values in the
1727 * current row or the insert row. The updater methods do not
1728 * update the underlying database; instead the <code>updateRow</code> or
1729 * <code>insertRow</code> methods are called to update the database.
1730 *
1731 * @param columnIndex the first column is 1, the second is 2, ...
1732 * @param x the new column value
1733 * @exception SQLException if the columnIndex is not valid;
1734 * if a database access error occurs;
1735 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1736 * or this method is called on a closed result set
1737 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1738 * this method
1739 * @since 1.2
1740 */
1741 void updateTime(int columnIndex, java.sql.Time x)
1742 throws SQLException;
1743
1744 /**
1745 * Updates the designated column with a <code>java.sql.Timestamp</code>
1746 * value.
1747 * The updater methods are used to update column values in the
1748 * current row or the insert row. The updater methods do not
1749 * update the underlying database; instead the <code>updateRow</code> or
1750 * <code>insertRow</code> methods are called to update the database.
1751 *
1752 * @param columnIndex the first column is 1, the second is 2, ...
1753 * @param x the new column value
1754 * @exception SQLException if the columnIndex is not valid;
1755 * if a database access error occurs;
1756 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1757 * or this method is called on a closed result set
1758 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1759 * this method
1760 * @since 1.2
1761 */
1762 void updateTimestamp(int columnIndex, java.sql.Timestamp x)
1763 throws SQLException;
1764
1765 /**
1766 * Updates the designated column with an ascii stream value, which will have
1767 * the specified number of bytes.
1768 * The updater methods are used to update column values in the
1769 * current row or the insert row. The updater methods do not
1770 * update the underlying database; instead the <code>updateRow</code> or
1771 * <code>insertRow</code> methods are called to update the database.
1772 *
1773 * @param columnIndex the first column is 1, the second is 2, ...
1774 * @param x the new column value
1775 * @param length the length of the stream
1776 * @exception SQLException if the columnIndex is not valid;
1777 * if a database access error occurs;
1778 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1779 * or this method is called on a closed result set
1780 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1781 * this method
1782 * @since 1.2
1783 */
1784 void updateAsciiStream(int columnIndex, java.io.InputStream x,
1785 int length) throws SQLException;
1786
1787 /**
1788 * Updates the designated column with a binary stream value, which will have
1789 * the specified number of bytes.
1790 * The updater methods are used to update column values in the
1791 * current row or the insert row. The updater methods do not
1792 * update the underlying database; instead the <code>updateRow</code> or
1793 * <code>insertRow</code> methods are called to update the database.
1794 *
1795 * @param columnIndex the first column is 1, the second is 2, ...
1796 * @param x the new column value
1797 * @param length the length of the stream
1798 * @exception SQLException if the columnIndex is not valid;
1799 * if a database access error occurs;
1800 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1801 * or this method is called on a closed result set
1802 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1803 * this method
1804 * @since 1.2
1805 */
1806 void updateBinaryStream(int columnIndex, java.io.InputStream x,
1807 int length) throws SQLException;
1808
1809 /**
1810 * Updates the designated column with a character stream value, which will have
1811 * the specified number of bytes.
1812 * The updater methods are used to update column values in the
1813 * current row or the insert row. The updater methods do not
1814 * update the underlying database; instead the <code>updateRow</code> or
1815 * <code>insertRow</code> methods are called to update the database.
1816 *
1817 * @param columnIndex the first column is 1, the second is 2, ...
1818 * @param x the new column value
1819 * @param length the length of the stream
1820 * @exception SQLException if the columnIndex is not valid;
1821 * if a database access error occurs;
1822 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1823 * or this method is called on a closed result set
1824 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1825 * this method
1826 * @since 1.2
1827 */
1828 void updateCharacterStream(int columnIndex, java.io.Reader x,
1829 int length) throws SQLException;
1830
1831 /**
1832 * Updates the designated column with an <code>Object</code> value.
1833 * The updater methods are used to update column values in the
1834 * current row or the insert row. The updater methods do not
1835 * update the underlying database; instead the <code>updateRow</code> or
1836 * <code>insertRow</code> methods are called to update the database.
1837 *<p>
1838 * If the second argument is an <code>InputStream</code> then the stream must contain
1839 * the number of bytes specified by scaleOrLength. If the second argument is a
1840 * <code>Reader</code> then the reader must contain the number of characters specified
1841 * by scaleOrLength. If these conditions are not true the driver will generate a
1842 * <code>SQLException</code> when the statement is executed.
1843 *
1844 * @param columnIndex the first column is 1, the second is 2, ...
1845 * @param x the new column value
1846 * @param scaleOrLength for an object of <code>java.math.BigDecimal</code> ,
1847 * this is the number of digits after the decimal point. For
1848 * Java Object types <code>InputStream</code> and <code>Reader</code>,
1849 * this is the length
1850 * of the data in the stream or reader. For all other types,
1851 * this value will be ignored.
1852 * @exception SQLException if the columnIndex is not valid;
1853 * if a database access error occurs;
1854 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1855 * or this method is called on a closed result set
1856 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1857 * this method
1858 * @since 1.2
1859 */
1860 void updateObject(int columnIndex, Object x, int scaleOrLength)
1861 throws SQLException;
1862
1863 /**
1864 * Updates the designated column with an <code>Object</code> value.
1865 * The updater methods are used to update column values in the
1866 * current row or the insert row. The updater methods do not
1867 * update the underlying database; instead the <code>updateRow</code> or
1868 * <code>insertRow</code> methods are called to update the database.
1869 *
1870 * @param columnIndex the first column is 1, the second is 2, ...
1871 * @param x the new column value
1872 * @exception SQLException if the columnIndex is not valid;
1873 * if a database access error occurs;
1874 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1875 * or this method is called on a closed result set
1876 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1877 * this method
1878 * @since 1.2
1879 */
1880 void updateObject(int columnIndex, Object x) throws SQLException;
1881
1882 /**
1883 * Updates the designated column with a <code>null</code> value.
1884 * The updater methods are used to update column values in the
1885 * current row or the insert row. The updater methods do not
1886 * update the underlying database; instead the <code>updateRow</code> or
1887 * <code>insertRow</code> methods are called to update the database.
1888 *
1889 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
1890 * @exception SQLException if the columnLabel is not valid;
1891 * if a database access error occurs;
1892 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1893 * or this method is called on a closed result set
1894 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1895 * this method
1896 * @since 1.2
1897 */
1898 void updateNull(String columnLabel) throws SQLException;
1899
1900 /**
1901 * Updates the designated column with a <code>boolean</code> value.
1902 * The updater methods are used to update column values in the
1903 * current row or the insert row. The updater methods do not
1904 * update the underlying database; instead the <code>updateRow</code> or
1905 * <code>insertRow</code> methods are called to update the database.
1906 *
1907 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
1908 * @param x the new column value
1909 * @exception SQLException if the columnLabel is not valid;
1910 * if a database access error occurs;
1911 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1912 * or this method is called on a closed result set
1913 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1914 * this method
1915 * @since 1.2
1916 */
1917 void updateBoolean(String columnLabel, boolean x)
1918 throws SQLException;
1919
1920 /**
1921 * Updates the designated column with a <code>byte</code> value.
1922 * The updater methods are used to update column values in the
1923 * current row or the insert row. The updater methods do not
1924 * update the underlying database; instead the <code>updateRow</code> or
1925 * <code>insertRow</code> methods are called to update the database.
1926 *
1927 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
1928 * @param x the new column value
1929 * @exception SQLException if the columnLabel is not valid;
1930 * if a database access error occurs;
1931 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1932 * or this method is called on a closed result set
1933 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1934 * this method
1935 * @since 1.2
1936 */
1937 void updateByte(String columnLabel, byte x) throws SQLException;
1938
1939 /**
1940 * Updates the designated column with a <code>short</code> value.
1941 * The updater methods are used to update column values in the
1942 * current row or the insert row. The updater methods do not
1943 * update the underlying database; instead the <code>updateRow</code> or
1944 * <code>insertRow</code> methods are called to update the database.
1945 *
1946 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
1947 * @param x the new column value
1948 * @exception SQLException if the columnLabel is not valid;
1949 * if a database access error occurs;
1950 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1951 * or this method is called on a closed result set
1952 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1953 * this method
1954 * @since 1.2
1955 */
1956 void updateShort(String columnLabel, short x) throws SQLException;
1957
1958 /**
1959 * Updates the designated column with an <code>int</code> value.
1960 * The updater methods are used to update column values in the
1961 * current row or the insert row. The updater methods do not
1962 * update the underlying database; instead the <code>updateRow</code> or
1963 * <code>insertRow</code> methods are called to update the database.
1964 *
1965 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
1966 * @param x the new column value
1967 * @exception SQLException if the columnLabel is not valid;
1968 * if a database access error occurs;
1969 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1970 * or this method is called on a closed result set
1971 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1972 * this method
1973 * @since 1.2
1974 */
1975 void updateInt(String columnLabel, int x) throws SQLException;
1976
1977 /**
1978 * Updates the designated column with a <code>long</code> value.
1979 * The updater methods are used to update column values in the
1980 * current row or the insert row. The updater methods do not
1981 * update the underlying database; instead the <code>updateRow</code> or
1982 * <code>insertRow</code> methods are called to update the database.
1983 *
1984 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
1985 * @param x the new column value
1986 * @exception SQLException if the columnLabel is not valid;
1987 * if a database access error occurs;
1988 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
1989 * or this method is called on a closed result set
1990 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1991 * this method
1992 * @since 1.2
1993 */
1994 void updateLong(String columnLabel, long x) throws SQLException;
1995
1996 /**
1997 * Updates the designated column with a <code>float </code> value.
1998 * The updater methods are used to update column values in the
1999 * current row or the insert row. The updater methods do not
2000 * update the underlying database; instead the <code>updateRow</code> or
2001 * <code>insertRow</code> methods are called to update the database.
2002 *
2003 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2004 * @param x the new column value
2005 * @exception SQLException if the columnLabel is not valid;
2006 * if a database access error occurs;
2007 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2008 * or this method is called on a closed result set
2009 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2010 * this method
2011 * @since 1.2
2012 */
2013 void updateFloat(String columnLabel, float x) throws SQLException;
2014
2015 /**
2016 * Updates the designated column with a <code>double</code> value.
2017 * The updater methods are used to update column values in the
2018 * current row or the insert row. The updater methods do not
2019 * update the underlying database; instead the <code>updateRow</code> or
2020 * <code>insertRow</code> methods are called to update the database.
2021 *
2022 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2023 * @param x the new column value
2024 * @exception SQLException if the columnLabel is not valid;
2025 * if a database access error occurs;
2026 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2027 * or this method is called on a closed result set
2028 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2029 * this method
2030 * @since 1.2
2031 */
2032 void updateDouble(String columnLabel, double x) throws SQLException;
2033
2034 /**
2035 * Updates the designated column with a <code>java.sql.BigDecimal</code>
2036 * value.
2037 * The updater methods are used to update column values in the
2038 * current row or the insert row. The updater methods do not
2039 * update the underlying database; instead the <code>updateRow</code> or
2040 * <code>insertRow</code> methods are called to update the database.
2041 *
2042 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2043 * @param x the new column value
2044 * @exception SQLException if the columnLabel is not valid;
2045 * if a database access error occurs;
2046 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2047 * or this method is called on a closed result set
2048 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2049 * this method
2050 * @since 1.2
2051 */
2052 void updateBigDecimal(String columnLabel, BigDecimal x)
2053 throws SQLException;
2054
2055 /**
2056 * Updates the designated column with a <code>String</code> value.
2057 * The updater methods are used to update column values in the
2058 * current row or the insert row. The updater methods do not
2059 * update the underlying database; instead the <code>updateRow</code> or
2060 * <code>insertRow</code> methods are called to update the database.
2061 *
2062 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2063 * @param x the new column value
2064 * @exception SQLException if the columnLabel is not valid;
2065 * if a database access error occurs;
2066 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2067 * or this method is called on a closed result set
2068 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2069 * this method
2070 * @since 1.2
2071 */
2072 void updateString(String columnLabel, String x) throws SQLException;
2073
2074 /**
2075 * Updates the designated column with a byte array value.
2076 *
2077 * The updater methods are used to update column values in the
2078 * current row or the insert row. The updater methods do not
2079 * update the underlying database; instead the <code>updateRow</code>
2080 * or <code>insertRow</code> methods are called to update the database.
2081 *
2082 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2083 * @param x the new column value
2084 * @exception SQLException if the columnLabel is not valid;
2085 * if a database access error occurs;
2086 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2087 * or this method is called on a closed result set
2088 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2089 * this method
2090 * @since 1.2
2091 */
2092 void updateBytes(String columnLabel, byte x[]) throws SQLException;
2093
2094 /**
2095 * Updates the designated column with a <code>java.sql.Date</code> value.
2096 * The updater methods are used to update column values in the
2097 * current row or the insert row. The updater methods do not
2098 * update the underlying database; instead the <code>updateRow</code> or
2099 * <code>insertRow</code> methods are called to update the database.
2100 *
2101 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2102 * @param x the new column value
2103 * @exception SQLException if the columnLabel is not valid;
2104 * if a database access error occurs;
2105 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2106 * or this method is called on a closed result set
2107 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2108 * this method
2109 * @since 1.2
2110 */
2111 void updateDate(String columnLabel, java.sql.Date x)
2112 throws SQLException;
2113
2114 /**
2115 * Updates the designated column with a <code>java.sql.Time</code> value.
2116 * The updater methods are used to update column values in the
2117 * current row or the insert row. The updater methods do not
2118 * update the underlying database; instead the <code>updateRow</code> or
2119 * <code>insertRow</code> methods are called to update the database.
2120 *
2121 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2122 * @param x the new column value
2123 * @exception SQLException if the columnLabel is not valid;
2124 * if a database access error occurs;
2125 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2126 * or this method is called on a closed result set
2127 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2128 * this method
2129 * @since 1.2
2130 */
2131 void updateTime(String columnLabel, java.sql.Time x)
2132 throws SQLException;
2133
2134 /**
2135 * Updates the designated column with a <code>java.sql.Timestamp</code>
2136 * value.
2137 * The updater methods are used to update column values in the
2138 * current row or the insert row. The updater methods do not
2139 * update the underlying database; instead the <code>updateRow</code> or
2140 * <code>insertRow</code> methods are called to update the database.
2141 *
2142 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2143 * @param x the new column value
2144 * @exception SQLException if the columnLabel is not valid;
2145 * if a database access error occurs;
2146 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2147 * or this method is called on a closed result set
2148 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2149 * this method
2150 * @since 1.2
2151 */
2152 void updateTimestamp(String columnLabel, java.sql.Timestamp x)
2153 throws SQLException;
2154
2155 /**
2156 * Updates the designated column with an ascii stream value, which will have
2157 * the specified number of bytes.
2158 * The updater methods are used to update column values in the
2159 * current row or the insert row. The updater methods do not
2160 * update the underlying database; instead the <code>updateRow</code> or
2161 * <code>insertRow</code> methods are called to update the database.
2162 *
2163 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2164 * @param x the new column value
2165 * @param length the length of the stream
2166 * @exception SQLException if the columnLabel is not valid;
2167 * if a database access error occurs;
2168 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2169 * or this method is called on a closed result set
2170 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2171 * this method
2172 * @since 1.2
2173 */
2174 void updateAsciiStream(String columnLabel, java.io.InputStream x,
2175 int length) throws SQLException;
2176
2177 /**
2178 * Updates the designated column with a binary stream value, which will have
2179 * the specified number of bytes.
2180 * The updater methods are used to update column values in the
2181 * current row or the insert row. The updater methods do not
2182 * update the underlying database; instead the <code>updateRow</code> or
2183 * <code>insertRow</code> methods are called to update the database.
2184 *
2185 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2186 * @param x the new column value
2187 * @param length the length of the stream
2188 * @exception SQLException if the columnLabel is not valid;
2189 * if a database access error occurs;
2190 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2191 * or this method is called on a closed result set
2192 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2193 * this method
2194 * @since 1.2
2195 */
2196 void updateBinaryStream(String columnLabel, java.io.InputStream x,
2197 int length) throws SQLException;
2198
2199 /**
2200 * Updates the designated column with a character stream value, which will have
2201 * the specified number of bytes.
2202 * The updater methods are used to update column values in the
2203 * current row or the insert row. The updater methods do not
2204 * update the underlying database; instead the <code>updateRow</code> or
2205 * <code>insertRow</code> methods are called to update the database.
2206 *
2207 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2208 * @param reader the <code>java.io.Reader</code> object containing
2209 * the new column value
2210 * @param length the length of the stream
2211 * @exception SQLException if the columnLabel is not valid;
2212 * if a database access error occurs;
2213 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2214 * or this method is called on a closed result set
2215 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2216 * this method
2217 * @since 1.2
2218 */
2219 void updateCharacterStream(String columnLabel,
2220 java.io.Reader reader, int length) throws SQLException;
2221
2222 /**
2223 * Updates the designated column with an <code>Object</code> value.
2224 * The updater methods are used to update column values in the
2225 * current row or the insert row. The updater methods do not
2226 * update the underlying database; instead the <code>updateRow</code> or
2227 * <code>insertRow</code> methods are called to update the database.
2228 *<p>
2229 * If the second argument is an <code>InputStream</code> then the stream must contain
2230 * the number of bytes specified by scaleOrLength. If the second argument is a
2231 * <code>Reader</code> then the reader must contain the number of characters specified
2232 * by scaleOrLength. If these conditions are not true the driver will generate a
2233 * <code>SQLException</code> when the statement is executed.
2234 *
2235 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2236 * @param x the new column value
2237 * @param scaleOrLength for an object of <code>java.math.BigDecimal</code> ,
2238 * this is the number of digits after the decimal point. For
2239 * Java Object types <code>InputStream</code> and <code>Reader</code>,
2240 * this is the length
2241 * of the data in the stream or reader. For all other types,
2242 * this value will be ignored.
2243 * @exception SQLException if the columnLabel is not valid;
2244 * if a database access error occurs;
2245 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2246 * or this method is called on a closed result set
2247 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2248 * this method
2249 * @since 1.2
2250 */
2251 void updateObject(String columnLabel, Object x, int scaleOrLength)
2252 throws SQLException;
2253
2254 /**
2255 * Updates the designated column with an <code>Object</code> value.
2256 * The updater methods are used to update column values in the
2257 * current row or the insert row. The updater methods do not
2258 * update the underlying database; instead the <code>updateRow</code> or
2259 * <code>insertRow</code> methods are called to update the database.
2260 *
2261 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2262 * @param x the new column value
2263 * @exception SQLException if the columnLabel is not valid;
2264 * if a database access error occurs;
2265 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2266 * or this method is called on a closed result set
2267 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2268 * this method
2269 * @since 1.2
2270 */
2271 void updateObject(String columnLabel, Object x) throws SQLException;
2272
2273 /**
2274 * Inserts the contents of the insert row into this
2275 * <code>ResultSet</code> object and into the database.
2276 * The cursor must be on the insert row when this method is called.
2277 *
2278 * @exception SQLException if a database access error occurs;
2279 * the result set concurrency is <code>CONCUR_READ_ONLY</code>,
2280 * this method is called on a closed result set,
2281 * if this method is called when the cursor is not on the insert row,
2282 * or if not all of non-nullable columns in
2283 * the insert row have been given a non-null value
2284 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2285 * this method
2286 * @since 1.2
2287 */
2288 void insertRow() throws SQLException;
2289
2290 /**
2291 * Updates the underlying database with the new contents of the
2292 * current row of this <code>ResultSet</code> object.
2293 * This method cannot be called when the cursor is on the insert row.
2294 *
2295 * @exception SQLException if a database access error occurs;
2296 * the result set concurrency is <code>CONCUR_READ_ONLY</code>;
2297 * this method is called on a closed result set or
2298 * if this method is called when the cursor is on the insert row
2299 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2300 * this method
2301 * @since 1.2
2302 */
2303 void updateRow() throws SQLException;
2304
2305 /**
2306 * Deletes the current row from this <code>ResultSet</code> object
2307 * and from the underlying database. This method cannot be called when
2308 * the cursor is on the insert row.
2309 *
2310 * @exception SQLException if a database access error occurs;
2311 * the result set concurrency is <code>CONCUR_READ_ONLY</code>;
2312 * this method is called on a closed result set
2313 * or if this method is called when the cursor is on the insert row
2314 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2315 * this method
2316 * @since 1.2
2317 */
2318 void deleteRow() throws SQLException;
2319
2320 /**
2321 * Refreshes the current row with its most recent value in
2322 * the database. This method cannot be called when
2323 * the cursor is on the insert row.
2324 *
2325 * <P>The <code>refreshRow</code> method provides a way for an
2326 * application to
2327 * explicitly tell the JDBC driver to refetch a row(s) from the
2328 * database. An application may want to call <code>refreshRow</code> when
2329 * caching or prefetching is being done by the JDBC driver to
2330 * fetch the latest value of a row from the database. The JDBC driver
2331 * may actually refresh multiple rows at once if the fetch size is
2332 * greater than one.
2333 *
2334 * <P> All values are refetched subject to the transaction isolation
2335 * level and cursor sensitivity. If <code>refreshRow</code> is called after
2336 * calling an updater method, but before calling
2337 * the method <code>updateRow</code>, then the
2338 * updates made to the row are lost. Calling the method
2339 * <code>refreshRow</code> frequently will likely slow performance.
2340 *
2341 * @exception SQLException if a database access error
2342 * occurs; this method is called on a closed result set;
2343 * the result set type is <code>TYPE_FORWARD_ONLY</code> or if this
2344 * method is called when the cursor is on the insert row
2345 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2346 * this method or this method is not supported for the specified result
2347 * set type and result set concurrency.
2348 * @since 1.2
2349 */
2350 void refreshRow() throws SQLException;
2351
2352 /**
2353 * Cancels the updates made to the current row in this
2354 * <code>ResultSet</code> object.
2355 * This method may be called after calling an
2356 * updater method(s) and before calling
2357 * the method <code>updateRow</code> to roll back
2358 * the updates made to a row. If no updates have been made or
2359 * <code>updateRow</code> has already been called, this method has no
2360 * effect.
2361 *
2362 * @exception SQLException if a database access error
2363 * occurs; this method is called on a closed result set;
2364 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2365 * or if this method is called when the cursor is
2366 * on the insert row
2367 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2368 * this method
2369 * @since 1.2
2370 */
2371 void cancelRowUpdates() throws SQLException;
2372
2373 /**
2374 * Moves the cursor to the insert row. The current cursor position is
2375 * remembered while the cursor is positioned on the insert row.
2376 *
2377 * The insert row is a special row associated with an updatable
2378 * result set. It is essentially a buffer where a new row may
2379 * be constructed by calling the updater methods prior to
2380 * inserting the row into the result set.
2381 *
2382 * Only the updater, getter,
2383 * and <code>insertRow</code> methods may be
2384 * called when the cursor is on the insert row. All of the columns in
2385 * a result set must be given a value each time this method is
2386 * called before calling <code>insertRow</code>.
2387 * An updater method must be called before a
2388 * getter method can be called on a column value.
2389 *
2390 * @exception SQLException if a database access error occurs; this
2391 * method is called on a closed result set
2392 * or the result set concurrency is <code>CONCUR_READ_ONLY</code>
2393 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2394 * this method
2395 * @since 1.2
2396 */
2397 void moveToInsertRow() throws SQLException;
2398
2399 /**
2400 * Moves the cursor to the remembered cursor position, usually the
2401 * current row. This method has no effect if the cursor is not on
2402 * the insert row.
2403 *
2404 * @exception SQLException if a database access error occurs; this
2405 * method is called on a closed result set
2406 * or the result set concurrency is <code>CONCUR_READ_ONLY</code>
2407 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2408 * this method
2409 * @since 1.2
2410 */
2411 void moveToCurrentRow() throws SQLException;
2412
2413 /**
2414 * Retrieves the <code>Statement</code> object that produced this
2415 * <code>ResultSet</code> object.
2416 * If the result set was generated some other way, such as by a
2417 * <code>DatabaseMetaData</code> method, this method may return
2418 * <code>null</code>.
2419 *
2420 * @return the <code>Statment</code> object that produced
2421 * this <code>ResultSet</code> object or <code>null</code>
2422 * if the result set was produced some other way
2423 * @exception SQLException if a database access error occurs
2424 * or this method is called on a closed result set
2425 * @since 1.2
2426 */
2427 Statement getStatement() throws SQLException;
2428
2429 /**
2430 * Retrieves the value of the designated column in the current row
2431 * of this <code>ResultSet</code> object as an <code>Object</code>
2432 * in the Java programming language.
2433 * If the value is an SQL <code>NULL</code>,
2434 * the driver returns a Java <code>null</code>.
2435 * This method uses the given <code>Map</code> object
2436 * for the custom mapping of the
2437 * SQL structured or distinct type that is being retrieved.
2438 *
2439 * @param columnIndex the first column is 1, the second is 2, ...
2440 * @param map a <code>java.util.Map</code> object that contains the mapping
2441 * from SQL type names to classes in the Java programming language
2442 * @return an <code>Object</code> in the Java programming language
2443 * representing the SQL value
2444 * @exception SQLException if the columnIndex is not valid;
2445 * if a database access error occurs
2446 * or this method is called on a closed result set
2447 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2448 * this method
2449 * @since 1.2
2450 */
2451 Object getObject(int columnIndex,
2452 java.util.Map<String, Class<?>> map) throws SQLException;
2453
2454 /**
2455 * Retrieves the value of the designated column in the current row
2456 * of this <code>ResultSet</code> object as a <code>Ref</code> object
2457 * in the Java programming language.
2458 *
2459 * @param columnIndex the first column is 1, the second is 2, ...
2460 * @return a <code>Ref</code> object representing an SQL <code>REF</code>
2461 * value
2462 * @exception SQLException if the columnIndex is not valid;
2463 * if a database access error occurs
2464 * or this method is called on a closed result set
2465 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2466 * this method
2467 * @since 1.2
2468 */
2469 Ref getRef(int columnIndex) throws SQLException;
2470
2471 /**
2472 * Retrieves the value of the designated column in the current row
2473 * of this <code>ResultSet</code> object as a <code>Blob</code> object
2474 * in the Java programming language.
2475 *
2476 * @param columnIndex the first column is 1, the second is 2, ...
2477 * @return a <code>Blob</code> object representing the SQL
2478 * <code>BLOB</code> value in the specified column
2479 * @exception SQLException if the columnIndex is not valid;
2480 * if a database access error occurs
2481 * or this method is called on a closed result set
2482 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2483 * this method
2484 * @since 1.2
2485 */
2486 Blob getBlob(int columnIndex) throws SQLException;
2487
2488 /**
2489 * Retrieves the value of the designated column in the current row
2490 * of this <code>ResultSet</code> object as a <code>Clob</code> object
2491 * in the Java programming language.
2492 *
2493 * @param columnIndex the first column is 1, the second is 2, ...
2494 * @return a <code>Clob</code> object representing the SQL
2495 * <code>CLOB</code> value in the specified column
2496 * @exception SQLException if the columnIndex is not valid;
2497 * if a database access error occurs
2498 * or this method is called on a closed result set
2499 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2500 * this method
2501 * @since 1.2
2502 */
2503 Clob getClob(int columnIndex) throws SQLException;
2504
2505 /**
2506 * Retrieves the value of the designated column in the current row
2507 * of this <code>ResultSet</code> object as an <code>Array</code> object
2508 * in the Java programming language.
2509 *
2510 * @param columnIndex the first column is 1, the second is 2, ...
2511 * @return an <code>Array</code> object representing the SQL
2512 * <code>ARRAY</code> value in the specified column
2513 * @exception SQLException if the columnIndex is not valid;
2514 * if a database access error occurs
2515 * or this method is called on a closed result set
2516 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2517 * this method
2518 * @since 1.2
2519 */
2520 Array getArray(int columnIndex) throws SQLException;
2521
2522 /**
2523 * Retrieves the value of the designated column in the current row
2524 * of this <code>ResultSet</code> object as an <code>Object</code>
2525 * in the Java programming language.
2526 * If the value is an SQL <code>NULL</code>,
2527 * the driver returns a Java <code>null</code>.
2528 * This method uses the specified <code>Map</code> object for
2529 * custom mapping if appropriate.
2530 *
2531 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2532 * @param map a <code>java.util.Map</code> object that contains the mapping
2533 * from SQL type names to classes in the Java programming language
2534 * @return an <code>Object</code> representing the SQL value in the
2535 * specified column
2536 * @exception SQLException if the columnLabel is not valid;
2537 * if a database access error occurs
2538 * or this method is called on a closed result set
2539 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2540 * this method
2541 * @since 1.2
2542 */
2543 Object getObject(String columnLabel,
2544 java.util.Map<String, Class<?>> map) throws SQLException;
2545
2546 /**
2547 * Retrieves the value of the designated column in the current row
2548 * of this <code>ResultSet</code> object as a <code>Ref</code> object
2549 * in the Java programming language.
2550 *
2551 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2552 * @return a <code>Ref</code> object representing the SQL <code>REF</code>
2553 * value in the specified column
2554 * @exception SQLException if the columnLabel is not valid;
2555 * if a database access error occurs
2556 * or this method is called on a closed result set
2557 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2558 * this method
2559 * @since 1.2
2560 */
2561 Ref getRef(String columnLabel) throws SQLException;
2562
2563 /**
2564 * Retrieves the value of the designated column in the current row
2565 * of this <code>ResultSet</code> object as a <code>Blob</code> object
2566 * in the Java programming language.
2567 *
2568 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2569 * @return a <code>Blob</code> object representing the SQL <code>BLOB</code>
2570 * value in the specified column
2571 * @exception SQLException if the columnLabel is not valid;
2572 * if a database access error occurs
2573 * or this method is called on a closed result set
2574 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2575 * this method
2576 * @since 1.2
2577 */
2578 Blob getBlob(String columnLabel) throws SQLException;
2579
2580 /**
2581 * Retrieves the value of the designated column in the current row
2582 * of this <code>ResultSet</code> object as a <code>Clob</code> object
2583 * in the Java programming language.
2584 *
2585 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2586 * @return a <code>Clob</code> object representing the SQL <code>CLOB</code>
2587 * value in the specified column
2588 * @exception SQLException if the columnLabel is not valid;
2589 * if a database access error occurs
2590 * or this method is called on a closed result set
2591 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2592 * this method
2593 * @since 1.2
2594 */
2595 Clob getClob(String columnLabel) throws SQLException;
2596
2597 /**
2598 * Retrieves the value of the designated column in the current row
2599 * of this <code>ResultSet</code> object as an <code>Array</code> object
2600 * in the Java programming language.
2601 *
2602 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2603 * @return an <code>Array</code> object representing the SQL <code>ARRAY</code> value in
2604 * the specified column
2605 * @exception SQLException if the columnLabel is not valid;
2606 * if a database access error occurs
2607 * or this method is called on a closed result set
2608 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2609 * this method
2610 * @since 1.2
2611 */
2612 Array getArray(String columnLabel) throws SQLException;
2613
2614 /**
2615 * Retrieves the value of the designated column in the current row
2616 * of this <code>ResultSet</code> object as a <code>java.sql.Date</code> object
2617 * in the Java programming language.
2618 * This method uses the given calendar to construct an appropriate millisecond
2619 * value for the date if the underlying database does not store
2620 * timezone information.
2621 *
2622 * @param columnIndex the first column is 1, the second is 2, ...
2623 * @param cal the <code>java.util.Calendar</code> object
2624 * to use in constructing the date
2625 * @return the column value as a <code>java.sql.Date</code> object;
2626 * if the value is SQL <code>NULL</code>,
2627 * the value returned is <code>null</code> in the Java programming language
2628 * @exception SQLException if the columnIndex is not valid;
2629 * if a database access error occurs
2630 * or this method is called on a closed result set
2631 * @since 1.2
2632 */
2633 java.sql.Date getDate(int columnIndex, Calendar cal)
2634 throws SQLException;
2635
2636 /**
2637 * Retrieves the value of the designated column in the current row
2638 * of this <code>ResultSet</code> object as a <code>java.sql.Date</code> object
2639 * in the Java programming language.
2640 * This method uses the given calendar to construct an appropriate millisecond
2641 * value for the date if the underlying database does not store
2642 * timezone information.
2643 *
2644 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2645 * @param cal the <code>java.util.Calendar</code> object
2646 * to use in constructing the date
2647 * @return the column value as a <code>java.sql.Date</code> object;
2648 * if the value is SQL <code>NULL</code>,
2649 * the value returned is <code>null</code> in the Java programming language
2650 * @exception SQLException if the columnLabel is not valid;
2651 * if a database access error occurs
2652 * or this method is called on a closed result set
2653 * @since 1.2
2654 */
2655 java.sql.Date getDate(String columnLabel, Calendar cal)
2656 throws SQLException;
2657
2658 /**
2659 * Retrieves the value of the designated column in the current row
2660 * of this <code>ResultSet</code> object as a <code>java.sql.Time</code> object
2661 * in the Java programming language.
2662 * This method uses the given calendar to construct an appropriate millisecond
2663 * value for the time if the underlying database does not store
2664 * timezone information.
2665 *
2666 * @param columnIndex the first column is 1, the second is 2, ...
2667 * @param cal the <code>java.util.Calendar</code> object
2668 * to use in constructing the time
2669 * @return the column value as a <code>java.sql.Time</code> object;
2670 * if the value is SQL <code>NULL</code>,
2671 * the value returned is <code>null</code> in the Java programming language
2672 * @exception SQLException if the columnIndex is not valid;
2673 * if a database access error occurs
2674 * or this method is called on a closed result set
2675 * @since 1.2
2676 */
2677 java.sql.Time getTime(int columnIndex, Calendar cal)
2678 throws SQLException;
2679
2680 /**
2681 * Retrieves the value of the designated column in the current row
2682 * of this <code>ResultSet</code> object as a <code>java.sql.Time</code> object
2683 * in the Java programming language.
2684 * This method uses the given calendar to construct an appropriate millisecond
2685 * value for the time if the underlying database does not store
2686 * timezone information.
2687 *
2688 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2689 * @param cal the <code>java.util.Calendar</code> object
2690 * to use in constructing the time
2691 * @return the column value as a <code>java.sql.Time</code> object;
2692 * if the value is SQL <code>NULL</code>,
2693 * the value returned is <code>null</code> in the Java programming language
2694 * @exception SQLException if the columnLabel is not valid;
2695 * if a database access error occurs
2696 * or this method is called on a closed result set
2697 * @since 1.2
2698 */
2699 java.sql.Time getTime(String columnLabel, Calendar cal)
2700 throws SQLException;
2701
2702 /**
2703 * Retrieves the value of the designated column in the current row
2704 * of this <code>ResultSet</code> object as a <code>java.sql.Timestamp</code> object
2705 * in the Java programming language.
2706 * This method uses the given calendar to construct an appropriate millisecond
2707 * value for the timestamp if the underlying database does not store
2708 * timezone information.
2709 *
2710 * @param columnIndex the first column is 1, the second is 2, ...
2711 * @param cal the <code>java.util.Calendar</code> object
2712 * to use in constructing the timestamp
2713 * @return the column value as a <code>java.sql.Timestamp</code> object;
2714 * if the value is SQL <code>NULL</code>,
2715 * the value returned is <code>null</code> in the Java programming language
2716 * @exception SQLException if the columnIndex is not valid;
2717 * if a database access error occurs
2718 * or this method is called on a closed result set
2719 * @since 1.2
2720 */
2721 java.sql.Timestamp getTimestamp(int columnIndex, Calendar cal)
2722 throws SQLException;
2723
2724 /**
2725 * Retrieves the value of the designated column in the current row
2726 * of this <code>ResultSet</code> object as a <code>java.sql.Timestamp</code> object
2727 * in the Java programming language.
2728 * This method uses the given calendar to construct an appropriate millisecond
2729 * value for the timestamp if the underlying database does not store
2730 * timezone information.
2731 *
2732 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2733 * @param cal the <code>java.util.Calendar</code> object
2734 * to use in constructing the date
2735 * @return the column value as a <code>java.sql.Timestamp</code> object;
2736 * if the value is SQL <code>NULL</code>,
2737 * the value returned is <code>null</code> in the Java programming language
2738 * @exception SQLException if the columnLabel is not valid or
2739 * if a database access error occurs
2740 * or this method is called on a closed result set
2741 * @since 1.2
2742 */
2743 java.sql.Timestamp getTimestamp(String columnLabel, Calendar cal)
2744 throws SQLException;
2745
2746 //-------------------------- JDBC 3.0 ----------------------------------------
2747
2748 /**
2749 * The constant indicating that open <code>ResultSet</code> objects with this
2750 * holdability will remain open when the current transaction is commited.
2751 *
2752 * @since 1.4
2753 */
2754 int HOLD_CURSORS_OVER_COMMIT = 1;
2755
2756 /**
2757 * The constant indicating that open <code>ResultSet</code> objects with this
2758 * holdability will be closed when the current transaction is commited.
2759 *
2760 * @since 1.4
2761 */
2762 int CLOSE_CURSORS_AT_COMMIT = 2;
2763
2764 /**
2765 * Retrieves the value of the designated column in the current row
2766 * of this <code>ResultSet</code> object as a <code>java.net.URL</code>
2767 * object in the Java programming language.
2768 *
2769 * @param columnIndex the index of the column 1 is the first, 2 is the second,...
2770 * @return the column value as a <code>java.net.URL</code> object;
2771 * if the value is SQL <code>NULL</code>,
2772 * the value returned is <code>null</code> in the Java programming language
2773 * @exception SQLException if the columnIndex is not valid;
2774 * if a database access error occurs; this method
2775 * is called on a closed result set or if a URL is malformed
2776 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2777 * this method
2778 * @since 1.4
2779 */
2780 java.net.URL getURL(int columnIndex) throws SQLException;
2781
2782 /**
2783 * Retrieves the value of the designated column in the current row
2784 * of this <code>ResultSet</code> object as a <code>java.net.URL</code>
2785 * object in the Java programming language.
2786 *
2787 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2788 * @return the column value as a <code>java.net.URL</code> object;
2789 * if the value is SQL <code>NULL</code>,
2790 * the value returned is <code>null</code> in the Java programming language
2791 * @exception SQLException if the columnLabel is not valid;
2792 * if a database access error occurs; this method
2793 * is called on a closed result set or if a URL is malformed
2794 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2795 * this method
2796 * @since 1.4
2797 */
2798 java.net.URL getURL(String columnLabel) throws SQLException;
2799
2800 /**
2801 * Updates the designated column with a <code>java.sql.Ref</code> value.
2802 * The updater methods are used to update column values in the
2803 * current row or the insert row. The updater methods do not
2804 * update the underlying database; instead the <code>updateRow</code> or
2805 * <code>insertRow</code> methods are called to update the database.
2806 *
2807 * @param columnIndex the first column is 1, the second is 2, ...
2808 * @param x the new column value
2809 * @exception SQLException if the columnIndex is not valid;
2810 * if a database access error occurs;
2811 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2812 * or this method is called on a closed result set
2813 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2814 * this method
2815 * @since 1.4
2816 */
2817 void updateRef(int columnIndex, java.sql.Ref x) throws SQLException;
2818
2819 /**
2820 * Updates the designated column with a <code>java.sql.Ref</code> value.
2821 * The updater methods are used to update column values in the
2822 * current row or the insert row. The updater methods do not
2823 * update the underlying database; instead the <code>updateRow</code> or
2824 * <code>insertRow</code> methods are called to update the database.
2825 *
2826 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2827 * @param x the new column value
2828 * @exception SQLException if the columnLabel is not valid;
2829 * if a database access error occurs;
2830 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2831 * or this method is called on a closed result set
2832 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2833 * this method
2834 * @since 1.4
2835 */
2836 void updateRef(String columnLabel, java.sql.Ref x)
2837 throws SQLException;
2838
2839 /**
2840 * Updates the designated column with a <code>java.sql.Blob</code> value.
2841 * The updater methods are used to update column values in the
2842 * current row or the insert row. The updater methods do not
2843 * update the underlying database; instead the <code>updateRow</code> or
2844 * <code>insertRow</code> methods are called to update the database.
2845 *
2846 * @param columnIndex the first column is 1, the second is 2, ...
2847 * @param x the new column value
2848 * @exception SQLException if the columnIndex is not valid;
2849 * if a database access error occurs;
2850 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2851 * or this method is called on a closed result set
2852 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2853 * this method
2854 * @since 1.4
2855 */
2856 void updateBlob(int columnIndex, java.sql.Blob x)
2857 throws SQLException;
2858
2859 /**
2860 * Updates the designated column with a <code>java.sql.Blob</code> value.
2861 * The updater methods are used to update column values in the
2862 * current row or the insert row. The updater methods do not
2863 * update the underlying database; instead the <code>updateRow</code> or
2864 * <code>insertRow</code> methods are called to update the database.
2865 *
2866 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2867 * @param x the new column value
2868 * @exception SQLException if the columnLabel is not valid;
2869 * if a database access error occurs;
2870 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2871 * or this method is called on a closed result set
2872 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2873 * this method
2874 * @since 1.4
2875 */
2876 void updateBlob(String columnLabel, java.sql.Blob x)
2877 throws SQLException;
2878
2879 /**
2880 * Updates the designated column with a <code>java.sql.Clob</code> value.
2881 * The updater methods are used to update column values in the
2882 * current row or the insert row. The updater methods do not
2883 * update the underlying database; instead the <code>updateRow</code> or
2884 * <code>insertRow</code> methods are called to update the database.
2885 *
2886 * @param columnIndex the first column is 1, the second is 2, ...
2887 * @param x the new column value
2888 * @exception SQLException if the columnIndex is not valid;
2889 * if a database access error occurs;
2890 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2891 * or this method is called on a closed result set
2892 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2893 * this method
2894 * @since 1.4
2895 */
2896 void updateClob(int columnIndex, java.sql.Clob x)
2897 throws SQLException;
2898
2899 /**
2900 * Updates the designated column with a <code>java.sql.Clob</code> value.
2901 * The updater methods are used to update column values in the
2902 * current row or the insert row. The updater methods do not
2903 * update the underlying database; instead the <code>updateRow</code> or
2904 * <code>insertRow</code> methods are called to update the database.
2905 *
2906 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2907 * @param x the new column value
2908 * @exception SQLException if the columnLabel is not valid;
2909 * if a database access error occurs;
2910 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2911 * or this method is called on a closed result set
2912 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2913 * this method
2914 * @since 1.4
2915 */
2916 void updateClob(String columnLabel, java.sql.Clob x)
2917 throws SQLException;
2918
2919 /**
2920 * Updates the designated column with a <code>java.sql.Array</code> value.
2921 * The updater methods are used to update column values in the
2922 * current row or the insert row. The updater methods do not
2923 * update the underlying database; instead the <code>updateRow</code> or
2924 * <code>insertRow</code> methods are called to update the database.
2925 *
2926 * @param columnIndex the first column is 1, the second is 2, ...
2927 * @param x the new column value
2928 * @exception SQLException if the columnIndex is not valid;
2929 * if a database access error occurs;
2930 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2931 * or this method is called on a closed result set
2932 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2933 * this method
2934 * @since 1.4
2935 */
2936 void updateArray(int columnIndex, java.sql.Array x)
2937 throws SQLException;
2938
2939 /**
2940 * Updates the designated column with a <code>java.sql.Array</code> value.
2941 * The updater methods are used to update column values in the
2942 * current row or the insert row. The updater methods do not
2943 * update the underlying database; instead the <code>updateRow</code> or
2944 * <code>insertRow</code> methods are called to update the database.
2945 *
2946 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2947 * @param x the new column value
2948 * @exception SQLException if the columnLabel is not valid;
2949 * if a database access error occurs;
2950 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
2951 * or this method is called on a closed result set
2952 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2953 * this method
2954 * @since 1.4
2955 */
2956 void updateArray(String columnLabel, java.sql.Array x)
2957 throws SQLException;
2958
2959 //------------------------- JDBC 4.0 -----------------------------------
2960
2961 /**
2962 * Retrieves the value of the designated column in the current row of this
2963 * <code>ResultSet</code> object as a <code>java.sql.RowId</code> object in the Java
2964 * programming language.
2965 *
2966 * @param columnIndex the first column is 1, the second 2, ...
2967 * @return the column value; if the value is a SQL <code>NULL</code> the
2968 * value returned is <code>null</code>
2969 * @throws SQLException if the columnIndex is not valid;
2970 * if a database access error occurs
2971 * or this method is called on a closed result set
2972 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2973 * this method
2974 * @since 1.6
2975 */
2976 RowId getRowId(int columnIndex) throws SQLException;
2977
2978 /**
2979 * Retrieves the value of the designated column in the current row of this
2980 * <code>ResultSet</code> object as a <code>java.sql.RowId</code> object in the Java
2981 * programming language.
2982 *
2983 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
2984 * @return the column value ; if the value is a SQL <code>NULL</code> the
2985 * value returned is <code>null</code>
2986 * @throws SQLException if the columnLabel is not valid;
2987 * if a database access error occurs
2988 * or this method is called on a closed result set
2989 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2990 * this method
2991 * @since 1.6
2992 */
2993 RowId getRowId(String columnLabel) throws SQLException;
2994
2995 /**
2996 * Updates the designated column with a <code>RowId</code> value. The updater
2997 * methods are used to update column values in the current row or the insert
2998 * row. The updater methods do not update the underlying database; instead
2999 * the <code>updateRow</code> or <code>insertRow</code> methods are called
3000 * to update the database.
3001 *
3002 * @param columnIndex the first column is 1, the second 2, ...
3003 * @param x the column value
3004 * @exception SQLException if the columnIndex is not valid;
3005 * if a database access error occurs;
3006 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3007 * or this method is called on a closed result set
3008 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3009 * this method
3010 * @since 1.6
3011 */
3012 void updateRowId(int columnIndex, RowId x) throws SQLException;
3013
3014 /**
3015 * Updates the designated column with a <code>RowId</code> value. The updater
3016 * methods are used to update column values in the current row or the insert
3017 * row. The updater methods do not update the underlying database; instead
3018 * the <code>updateRow</code> or <code>insertRow</code> methods are called
3019 * to update the database.
3020 *
3021 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3022 * @param x the column value
3023 * @exception SQLException if the columnLabel is not valid;
3024 * if a database access error occurs;
3025 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3026 * or this method is called on a closed result set
3027 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3028 * this method
3029 * @since 1.6
3030 */
3031 void updateRowId(String columnLabel, RowId x) throws SQLException;
3032
3033 /**
3034 * Retrieves the holdability of this <code>ResultSet</code> object
3035 * @return either <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code>
3036 * @throws SQLException if a database access error occurs
3037 * or this method is called on a closed result set
3038 * @since 1.6
3039 */
3040 int getHoldability() throws SQLException;
3041
3042 /**
3043 * Retrieves whether this <code>ResultSet</code> object has been closed. A <code>ResultSet</code> is closed if the
3044 * method close has been called on it, or if it is automatically closed.
3045 *
3046 * @return true if this <code>ResultSet</code> object is closed; false if it is still open
3047 * @throws SQLException if a database access error occurs
3048 * @since 1.6
3049 */
3050 boolean isClosed() throws SQLException;
3051
3052 /**
3053 * Updates the designated column with a <code>String</code> value.
3054 * It is intended for use when updating <code>NCHAR</code>,<code>NVARCHAR</code>
3055 * and <code>LONGNVARCHAR</code> columns.
3056 * The updater methods are used to update column values in the
3057 * current row or the insert row. The updater methods do not
3058 * update the underlying database; instead the <code>updateRow</code> or
3059 * <code>insertRow</code> methods are called to update the database.
3060 *
3061 * @param columnIndex the first column is 1, the second 2, ...
3062 * @param nString the value for the column to be updated
3063 * @throws SQLException if the columnIndex is not valid;
3064 * if the driver does not support national
3065 * character sets; if the driver can detect that a data conversion
3066 * error could occur; this method is called on a closed result set;
3067 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3068 * or if a database access error occurs
3069 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3070 * this method
3071 * @since 1.6
3072 */
3073 void updateNString(int columnIndex, String nString)
3074 throws SQLException;
3075
3076 /**
3077 * Updates the designated column with a <code>String</code> value.
3078 * It is intended for use when updating <code>NCHAR</code>,<code>NVARCHAR</code>
3079 * and <code>LONGNVARCHAR</code> columns.
3080 * The updater methods are used to update column values in the
3081 * current row or the insert row. The updater methods do not
3082 * update the underlying database; instead the <code>updateRow</code> or
3083 * <code>insertRow</code> methods are called to update the database.
3084 *
3085 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3086 * @param nString the value for the column to be updated
3087 * @throws SQLException if the columnLabel is not valid;
3088 * if the driver does not support national
3089 * character sets; if the driver can detect that a data conversion
3090 * error could occur; this method is called on a closed result set;
3091 * the result set concurrency is <CODE>CONCUR_READ_ONLY</code>
3092 * or if a database access error occurs
3093 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3094 * this method
3095 * @since 1.6
3096 */
3097 void updateNString(String columnLabel, String nString)
3098 throws SQLException;
3099
3100 /**
3101 * Updates the designated column with a <code>java.sql.NClob</code> value.
3102 * The updater methods are used to update column values in the
3103 * current row or the insert row. The updater methods do not
3104 * update the underlying database; instead the <code>updateRow</code> or
3105 * <code>insertRow</code> methods are called to update the database.
3106 *
3107 * @param columnIndex the first column is 1, the second 2, ...
3108 * @param nClob the value for the column to be updated
3109 * @throws SQLException if the columnIndex is not valid;
3110 * if the driver does not support national
3111 * character sets; if the driver can detect that a data conversion
3112 * error could occur; this method is called on a closed result set;
3113 * if a database access error occurs or
3114 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3115 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3116 * this method
3117 * @since 1.6
3118 */
3119 void updateNClob(int columnIndex, NClob nClob) throws SQLException;
3120
3121 /**
3122 * Updates the designated column with a <code>java.sql.NClob</code> value.
3123 * The updater methods are used to update column values in the
3124 * current row or the insert row. The updater methods do not
3125 * update the underlying database; instead the <code>updateRow</code> or
3126 * <code>insertRow</code> methods are called to update the database.
3127 *
3128 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3129 * @param nClob the value for the column to be updated
3130 * @throws SQLException if the columnLabel is not valid;
3131 * if the driver does not support national
3132 * character sets; if the driver can detect that a data conversion
3133 * error could occur; this method is called on a closed result set;
3134 * if a database access error occurs or
3135 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3136 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3137 * this method
3138 * @since 1.6
3139 */
3140 void updateNClob(String columnLabel, NClob nClob)
3141 throws SQLException;
3142
3143 /**
3144 * Retrieves the value of the designated column in the current row
3145 * of this <code>ResultSet</code> object as a <code>NClob</code> object
3146 * in the Java programming language.
3147 *
3148 * @param columnIndex the first column is 1, the second is 2, ...
3149 * @return a <code>NClob</code> object representing the SQL
3150 * <code>NCLOB</code> value in the specified column
3151 * @exception SQLException if the columnIndex is not valid;
3152 * if the driver does not support national
3153 * character sets; if the driver can detect that a data conversion
3154 * error could occur; this method is called on a closed result set
3155 * or if a database access error occurs
3156 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3157 * this method
3158 * @since 1.6
3159 */
3160 NClob getNClob(int columnIndex) throws SQLException;
3161
3162 /**
3163 * Retrieves the value of the designated column in the current row
3164 * of this <code>ResultSet</code> object as a <code>NClob</code> object
3165 * in the Java programming language.
3166 *
3167 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3168 * @return a <code>NClob</code> object representing the SQL <code>NCLOB</code>
3169 * value in the specified column
3170 * @exception SQLException if the columnLabel is not valid;
3171 * if the driver does not support national
3172 * character sets; if the driver can detect that a data conversion
3173 * error could occur; this method is called on a closed result set
3174 * or if a database access error occurs
3175 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3176 * this method
3177 * @since 1.6
3178 */
3179 NClob getNClob(String columnLabel) throws SQLException;
3180
3181 /**
3182 * Retrieves the value of the designated column in the current row of
3183 * this <code>ResultSet</code> as a
3184 * <code>java.sql.SQLXML</code> object in the Java programming language.
3185 * @param columnIndex the first column is 1, the second is 2, ...
3186 * @return a <code>SQLXML</code> object that maps an <code>SQL XML</code> value
3187 * @throws SQLException if the columnIndex is not valid;
3188 * if a database access error occurs
3189 * or this method is called on a closed result set
3190 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3191 * this method
3192 * @since 1.6
3193 */
3194 SQLXML getSQLXML(int columnIndex) throws SQLException;
3195
3196 /**
3197 * Retrieves the value of the designated column in the current row of
3198 * this <code>ResultSet</code> as a
3199 * <code>java.sql.SQLXML</code> object in the Java programming language.
3200 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3201 * @return a <code>SQLXML</code> object that maps an <code>SQL XML</code> value
3202 * @throws SQLException if the columnLabel is not valid;
3203 * if a database access error occurs
3204 * or this method is called on a closed result set
3205 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3206 * this method
3207 * @since 1.6
3208 */
3209 SQLXML getSQLXML(String columnLabel) throws SQLException;
3210
3211 /**
3212 * Updates the designated column with a <code>java.sql.SQLXML</code> value.
3213 * The updater
3214 * methods are used to update column values in the current row or the insert
3215 * row. The updater methods do not update the underlying database; instead
3216 * the <code>updateRow</code> or <code>insertRow</code> methods are called
3217 * to update the database.
3218 * <p>
3219 *
3220 * @param columnIndex the first column is 1, the second 2, ...
3221 * @param xmlObject the value for the column to be updated
3222 * @throws SQLException if the columnIndex is not valid;
3223 * if a database access error occurs; this method
3224 * is called on a closed result set;
3225 * the <code>java.xml.transform.Result</code>,
3226 * <code>Writer</code> or <code>OutputStream</code> has not been closed
3227 * for the <code>SQLXML</code> object;
3228 * if there is an error processing the XML value or
3229 * the result set concurrency is <code>CONCUR_READ_ONLY</code>. The <code>getCause</code> method
3230 * of the exception may provide a more detailed exception, for example, if the
3231 * stream does not contain valid XML.
3232 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3233 * this method
3234 * @since 1.6
3235 */
3236 void updateSQLXML(int columnIndex, SQLXML xmlObject)
3237 throws SQLException;
3238
3239 /**
3240 * Updates the designated column with a <code>java.sql.SQLXML</code> value.
3241 * The updater
3242 * methods are used to update column values in the current row or the insert
3243 * row. The updater methods do not update the underlying database; instead
3244 * the <code>updateRow</code> or <code>insertRow</code> methods are called
3245 * to update the database.
3246 * <p>
3247 *
3248 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3249 * @param xmlObject the column value
3250 * @throws SQLException if the columnLabel is not valid;
3251 * if a database access error occurs; this method
3252 * is called on a closed result set;
3253 * the <code>java.xml.transform.Result</code>,
3254 * <code>Writer</code> or <code>OutputStream</code> has not been closed
3255 * for the <code>SQLXML</code> object;
3256 * if there is an error processing the XML value or
3257 * the result set concurrency is <code>CONCUR_READ_ONLY</code>. The <code>getCause</code> method
3258 * of the exception may provide a more detailed exception, for example, if the
3259 * stream does not contain valid XML.
3260 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3261 * this method
3262 * @since 1.6
3263 */
3264 void updateSQLXML(String columnLabel, SQLXML xmlObject)
3265 throws SQLException;
3266
3267 /**
3268 * Retrieves the value of the designated column in the current row
3269 * of this <code>ResultSet</code> object as
3270 * a <code>String</code> in the Java programming language.
3271 * It is intended for use when
3272 * accessing <code>NCHAR</code>,<code>NVARCHAR</code>
3273 * and <code>LONGNVARCHAR</code> columns.
3274 *
3275 * @param columnIndex the first column is 1, the second is 2, ...
3276 * @return the column value; if the value is SQL <code>NULL</code>, the
3277 * value returned is <code>null</code>
3278 * @exception SQLException if the columnIndex is not valid;
3279 * if a database access error occurs
3280 * or this method is called on a closed result set
3281 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3282 * this method
3283 * @since 1.6
3284 */
3285 String getNString(int columnIndex) throws SQLException;
3286
3287 /**
3288 * Retrieves the value of the designated column in the current row
3289 * of this <code>ResultSet</code> object as
3290 * a <code>String</code> in the Java programming language.
3291 * It is intended for use when
3292 * accessing <code>NCHAR</code>,<code>NVARCHAR</code>
3293 * and <code>LONGNVARCHAR</code> columns.
3294 *
3295 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3296 * @return the column value; if the value is SQL <code>NULL</code>, the
3297 * value returned is <code>null</code>
3298 * @exception SQLException if the columnLabel is not valid;
3299 * if a database access error occurs
3300 * or this method is called on a closed result set
3301 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3302 * this method
3303 * @since 1.6
3304 */
3305 String getNString(String columnLabel) throws SQLException;
3306
3307 /**
3308 * Retrieves the value of the designated column in the current row
3309 * of this <code>ResultSet</code> object as a
3310 * <code>java.io.Reader</code> object.
3311 * It is intended for use when
3312 * accessing <code>NCHAR</code>,<code>NVARCHAR</code>
3313 * and <code>LONGNVARCHAR</code> columns.
3314 *
3315 * @return a <code>java.io.Reader</code> object that contains the column
3316 * value; if the value is SQL <code>NULL</code>, the value returned is
3317 * <code>null</code> in the Java programming language.
3318 * @param columnIndex the first column is 1, the second is 2, ...
3319 * @exception SQLException if the columnIndex is not valid;
3320 * if a database access error occurs
3321 * or this method is called on a closed result set
3322 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3323 * this method
3324 * @since 1.6
3325 */
3326 java.io.Reader getNCharacterStream(int columnIndex)
3327 throws SQLException;
3328
3329 /**
3330 * Retrieves the value of the designated column in the current row
3331 * of this <code>ResultSet</code> object as a
3332 * <code>java.io.Reader</code> object.
3333 * It is intended for use when
3334 * accessing <code>NCHAR</code>,<code>NVARCHAR</code>
3335 * and <code>LONGNVARCHAR</code> columns.
3336 *
3337 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3338 * @return a <code>java.io.Reader</code> object that contains the column
3339 * value; if the value is SQL <code>NULL</code>, the value returned is
3340 * <code>null</code> in the Java programming language
3341 * @exception SQLException if the columnLabel is not valid;
3342 * if a database access error occurs
3343 * or this method is called on a closed result set
3344 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3345 * this method
3346 * @since 1.6
3347 */
3348 java.io.Reader getNCharacterStream(String columnLabel)
3349 throws SQLException;
3350
3351 /**
3352 * Updates the designated column with a character stream value, which will have
3353 * the specified number of bytes. The
3354 * driver does the necessary conversion from Java character format to
3355 * the national character set in the database.
3356 * It is intended for use when
3357 * updating <code>NCHAR</code>,<code>NVARCHAR</code>
3358 * and <code>LONGNVARCHAR</code> columns.
3359 * <p>
3360 * The updater methods are used to update column values in the
3361 * current row or the insert row. The updater methods do not
3362 * update the underlying database; instead the <code>updateRow</code> or
3363 * <code>insertRow</code> methods are called to update the database.
3364 *
3365 * @param columnIndex the first column is 1, the second is 2, ...
3366 * @param x the new column value
3367 * @param length the length of the stream
3368 * @exception SQLException if the columnIndex is not valid;
3369 * if a database access error occurs;
3370 * the result set concurrency is <code>CONCUR_READ_ONLY</code> or this method is called on a closed result set
3371 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3372 * this method
3373 * @since 1.6
3374 */
3375 void updateNCharacterStream(int columnIndex, java.io.Reader x,
3376 long length) throws SQLException;
3377
3378 /**
3379 * Updates the designated column with a character stream value, which will have
3380 * the specified number of bytes. The
3381 * driver does the necessary conversion from Java character format to
3382 * the national character set in the database.
3383 * It is intended for use when
3384 * updating <code>NCHAR</code>,<code>NVARCHAR</code>
3385 * and <code>LONGNVARCHAR</code> columns.
3386 * <p>
3387 * The updater methods are used to update column values in the
3388 * current row or the insert row. The updater methods do not
3389 * update the underlying database; instead the <code>updateRow</code> or
3390 * <code>insertRow</code> methods are called to update the database.
3391 *
3392 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3393 * @param reader the <code>java.io.Reader</code> object containing
3394 * the new column value
3395 * @param length the length of the stream
3396 * @exception SQLException if the columnLabel is not valid;
3397 * if a database access error occurs;
3398 * the result set concurrency is <code>CONCUR_READ_ONLY</code> or this method is called on a closed result set
3399 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3400 * this method
3401 * @since 1.6
3402 */
3403 void updateNCharacterStream(String columnLabel,
3404 java.io.Reader reader, long length) throws SQLException;
3405
3406 /**
3407 * Updates the designated column with an ascii stream value, which will have
3408 * the specified number of bytes.
3409 * <p>
3410 * The updater methods are used to update column values in the
3411 * current row or the insert row. The updater methods do not
3412 * update the underlying database; instead the <code>updateRow</code> or
3413 * <code>insertRow</code> methods are called to update the database.
3414 *
3415 * @param columnIndex the first column is 1, the second is 2, ...
3416 * @param x the new column value
3417 * @param length the length of the stream
3418 * @exception SQLException if the columnIndex is not valid;
3419 * if a database access error occurs;
3420 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3421 * or this method is called on a closed result set
3422 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3423 * this method
3424 * @since 1.6
3425 */
3426 void updateAsciiStream(int columnIndex, java.io.InputStream x,
3427 long length) throws SQLException;
3428
3429 /**
3430 * Updates the designated column with a binary stream value, which will have
3431 * the specified number of bytes.
3432 * <p>
3433 * The updater methods are used to update column values in the
3434 * current row or the insert row. The updater methods do not
3435 * update the underlying database; instead the <code>updateRow</code> or
3436 * <code>insertRow</code> methods are called to update the database.
3437 *
3438 * @param columnIndex the first column is 1, the second is 2, ...
3439 * @param x the new column value
3440 * @param length the length of the stream
3441 * @exception SQLException if the columnIndex is not valid;
3442 * if a database access error occurs;
3443 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3444 * or this method is called on a closed result set
3445 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3446 * this method
3447 * @since 1.6
3448 */
3449 void updateBinaryStream(int columnIndex, java.io.InputStream x,
3450 long length) throws SQLException;
3451
3452 /**
3453 * Updates the designated column with a character stream value, which will have
3454 * the specified number of bytes.
3455 * <p>
3456 * The updater methods are used to update column values in the
3457 * current row or the insert row. The updater methods do not
3458 * update the underlying database; instead the <code>updateRow</code> or
3459 * <code>insertRow</code> methods are called to update the database.
3460 *
3461 * @param columnIndex the first column is 1, the second is 2, ...
3462 * @param x the new column value
3463 * @param length the length of the stream
3464 * @exception SQLException if the columnIndex is not valid;
3465 * if a database access error occurs;
3466 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3467 * or this method is called on a closed result set
3468 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3469 * this method
3470 * @since 1.6
3471 */
3472 void updateCharacterStream(int columnIndex, java.io.Reader x,
3473 long length) throws SQLException;
3474
3475 /**
3476 * Updates the designated column with an ascii stream value, which will have
3477 * the specified number of bytes.
3478 * <p>
3479 * The updater methods are used to update column values in the
3480 * current row or the insert row. The updater methods do not
3481 * update the underlying database; instead the <code>updateRow</code> or
3482 * <code>insertRow</code> methods are called to update the database.
3483 *
3484 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3485 * @param x the new column value
3486 * @param length the length of the stream
3487 * @exception SQLException if the columnLabel is not valid;
3488 * if a database access error occurs;
3489 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3490 * or this method is called on a closed result set
3491 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3492 * this method
3493 * @since 1.6
3494 */
3495 void updateAsciiStream(String columnLabel, java.io.InputStream x,
3496 long length) throws SQLException;
3497
3498 /**
3499 * Updates the designated column with a binary stream value, which will have
3500 * the specified number of bytes.
3501 * <p>
3502 * The updater methods are used to update column values in the
3503 * current row or the insert row. The updater methods do not
3504 * update the underlying database; instead the <code>updateRow</code> or
3505 * <code>insertRow</code> methods are called to update the database.
3506 *
3507 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3508 * @param x the new column value
3509 * @param length the length of the stream
3510 * @exception SQLException if the columnLabel is not valid;
3511 * if a database access error occurs;
3512 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3513 * or this method is called on a closed result set
3514 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3515 * this method
3516 * @since 1.6
3517 */
3518 void updateBinaryStream(String columnLabel, java.io.InputStream x,
3519 long length) throws SQLException;
3520
3521 /**
3522 * Updates the designated column with a character stream value, which will have
3523 * the specified number of bytes.
3524 * <p>
3525 * The updater methods are used to update column values in the
3526 * current row or the insert row. The updater methods do not
3527 * update the underlying database; instead the <code>updateRow</code> or
3528 * <code>insertRow</code> methods are called to update the database.
3529 *
3530 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3531 * @param reader the <code>java.io.Reader</code> object containing
3532 * the new column value
3533 * @param length the length of the stream
3534 * @exception SQLException if the columnLabel is not valid;
3535 * if a database access error occurs;
3536 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3537 * or this method is called on a closed result set
3538 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3539 * this method
3540 * @since 1.6
3541 */
3542 void updateCharacterStream(String columnLabel,
3543 java.io.Reader reader, long length) throws SQLException;
3544
3545 /**
3546 * Updates the designated column using the given input stream, which
3547 * will have the specified number of bytes.
3548 *
3549 * <p>
3550 * The updater methods are used to update column values in the
3551 * current row or the insert row. The updater methods do not
3552 * update the underlying database; instead the <code>updateRow</code> or
3553 * <code>insertRow</code> methods are called to update the database.
3554 *
3555 * @param columnIndex the first column is 1, the second is 2, ...
3556 * @param inputStream An object that contains the data to set the parameter
3557 * value to.
3558 * @param length the number of bytes in the parameter data.
3559 * @exception SQLException if the columnIndex is not valid;
3560 * if a database access error occurs;
3561 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3562 * or this method is called on a closed result set
3563 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3564 * this method
3565 * @since 1.6
3566 */
3567 void updateBlob(int columnIndex, InputStream inputStream,
3568 long length) throws SQLException;
3569
3570 /**
3571 * Updates the designated column using the given input stream, which
3572 * will have the specified number of bytes.
3573 *
3574 * <p>
3575 * The updater methods are used to update column values in the
3576 * current row or the insert row. The updater methods do not
3577 * update the underlying database; instead the <code>updateRow</code> or
3578 * <code>insertRow</code> methods are called to update the database.
3579 *
3580 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3581 * @param inputStream An object that contains the data to set the parameter
3582 * value to.
3583 * @param length the number of bytes in the parameter data.
3584 * @exception SQLException if the columnLabel is not valid;
3585 * if a database access error occurs;
3586 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3587 * or this method is called on a closed result set
3588 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3589 * this method
3590 * @since 1.6
3591 */
3592 void updateBlob(String columnLabel, InputStream inputStream,
3593 long length) throws SQLException;
3594
3595 /**
3596 * Updates the designated column using the given <code>Reader</code>
3597 * object, which is the given number of characters long.
3598 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
3599 * parameter, it may be more practical to send it via a
3600 * <code>java.io.Reader</code> object. The JDBC driver will
3601 * do any necessary conversion from UNICODE to the database char format.
3602 *
3603 * <p>
3604 * The updater methods are used to update column values in the
3605 * current row or the insert row. The updater methods do not
3606 * update the underlying database; instead the <code>updateRow</code> or
3607 * <code>insertRow</code> methods are called to update the database.
3608 *
3609 * @param columnIndex the first column is 1, the second is 2, ...
3610 * @param reader An object that contains the data to set the parameter value to.
3611 * @param length the number of characters in the parameter data.
3612 * @exception SQLException if the columnIndex is not valid;
3613 * if a database access error occurs;
3614 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3615 * or this method is called on a closed result set
3616 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3617 * this method
3618 * @since 1.6
3619 */
3620 void updateClob(int columnIndex, Reader reader, long length)
3621 throws SQLException;
3622
3623 /**
3624 * Updates the designated column using the given <code>Reader</code>
3625 * object, which is the given number of characters long.
3626 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
3627 * parameter, it may be more practical to send it via a
3628 * <code>java.io.Reader</code> object. The JDBC driver will
3629 * do any necessary conversion from UNICODE to the database char format.
3630 *
3631 * <p>
3632 * The updater methods are used to update column values in the
3633 * current row or the insert row. The updater methods do not
3634 * update the underlying database; instead the <code>updateRow</code> or
3635 * <code>insertRow</code> methods are called to update the database.
3636 *
3637 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3638 * @param reader An object that contains the data to set the parameter value to.
3639 * @param length the number of characters in the parameter data.
3640 * @exception SQLException if the columnLabel is not valid;
3641 * if a database access error occurs;
3642 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3643 * or this method is called on a closed result set
3644 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3645 * this method
3646 * @since 1.6
3647 */
3648 void updateClob(String columnLabel, Reader reader, long length)
3649 throws SQLException;
3650
3651 /**
3652 * Updates the designated column using the given <code>Reader</code>
3653 * object, which is the given number of characters long.
3654 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
3655 * parameter, it may be more practical to send it via a
3656 * <code>java.io.Reader</code> object. The JDBC driver will
3657 * do any necessary conversion from UNICODE to the database char format.
3658 *
3659 * <p>
3660 * The updater methods are used to update column values in the
3661 * current row or the insert row. The updater methods do not
3662 * update the underlying database; instead the <code>updateRow</code> or
3663 * <code>insertRow</code> methods are called to update the database.
3664 *
3665 * @param columnIndex the first column is 1, the second 2, ...
3666 * @param reader An object that contains the data to set the parameter value to.
3667 * @param length the number of characters in the parameter data.
3668 * @throws SQLException if the columnIndex is not valid;
3669 * if the driver does not support national
3670 * character sets; if the driver can detect that a data conversion
3671 * error could occur; this method is called on a closed result set,
3672 * if a database access error occurs or
3673 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3674 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3675 * this method
3676 * @since 1.6
3677 */
3678 void updateNClob(int columnIndex, Reader reader, long length)
3679 throws SQLException;
3680
3681 /**
3682 * Updates the designated column using the given <code>Reader</code>
3683 * object, which is the given number of characters long.
3684 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
3685 * parameter, it may be more practical to send it via a
3686 * <code>java.io.Reader</code> object. The JDBC driver will
3687 * do any necessary conversion from UNICODE to the database char format.
3688 *
3689 * <p>
3690 * The updater methods are used to update column values in the
3691 * current row or the insert row. The updater methods do not
3692 * update the underlying database; instead the <code>updateRow</code> or
3693 * <code>insertRow</code> methods are called to update the database.
3694 *
3695 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3696 * @param reader An object that contains the data to set the parameter value to.
3697 * @param length the number of characters in the parameter data.
3698 * @throws SQLException if the columnLabel is not valid;
3699 * if the driver does not support national
3700 * character sets; if the driver can detect that a data conversion
3701 * error could occur; this method is called on a closed result set;
3702 * if a database access error occurs or
3703 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3704 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3705 * this method
3706 * @since 1.6
3707 */
3708 void updateNClob(String columnLabel, Reader reader, long length)
3709 throws SQLException;
3710
3711 //---
3712
3713 /**
3714 * Updates the designated column with a character stream value.
3715 * The data will be read from the stream
3716 * as needed until end-of-stream is reached. The
3717 * driver does the necessary conversion from Java character format to
3718 * the national character set in the database.
3719 * It is intended for use when
3720 * updating <code>NCHAR</code>,<code>NVARCHAR</code>
3721 * and <code>LONGNVARCHAR</code> columns.
3722 * <p>
3723 * The updater methods are used to update column values in the
3724 * current row or the insert row. The updater methods do not
3725 * update the underlying database; instead the <code>updateRow</code> or
3726 * <code>insertRow</code> methods are called to update the database.
3727 *
3728 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3729 * it might be more efficient to use a version of
3730 * <code>updateNCharacterStream</code> which takes a length parameter.
3731 *
3732 * @param columnIndex the first column is 1, the second is 2, ...
3733 * @param x the new column value
3734 * @exception SQLException if the columnIndex is not valid;
3735 * if a database access error occurs;
3736 * the result set concurrency is <code>CONCUR_READ_ONLY</code> or this method is called on a closed result set
3737 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3738 * this method
3739 * @since 1.6
3740 */
3741 void updateNCharacterStream(int columnIndex, java.io.Reader x)
3742 throws SQLException;
3743
3744 /**
3745 * Updates the designated column with a character stream value.
3746 * The data will be read from the stream
3747 * as needed until end-of-stream is reached. The
3748 * driver does the necessary conversion from Java character format to
3749 * the national character set in the database.
3750 * It is intended for use when
3751 * updating <code>NCHAR</code>,<code>NVARCHAR</code>
3752 * and <code>LONGNVARCHAR</code> columns.
3753 * <p>
3754 * The updater methods are used to update column values in the
3755 * current row or the insert row. The updater methods do not
3756 * update the underlying database; instead the <code>updateRow</code> or
3757 * <code>insertRow</code> methods are called to update the database.
3758 *
3759 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3760 * it might be more efficient to use a version of
3761 * <code>updateNCharacterStream</code> which takes a length parameter.
3762 *
3763 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3764 * @param reader the <code>java.io.Reader</code> object containing
3765 * the new column value
3766 * @exception SQLException if the columnLabel is not valid;
3767 * if a database access error occurs;
3768 * the result set concurrency is <code>CONCUR_READ_ONLY</code> or this method is called on a closed result set
3769 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3770 * this method
3771 * @since 1.6
3772 */
3773 void updateNCharacterStream(String columnLabel,
3774 java.io.Reader reader) throws SQLException;
3775
3776 /**
3777 * Updates the designated column with an ascii stream value.
3778 * The data will be read from the stream
3779 * as needed until end-of-stream is reached.
3780 * <p>
3781 * The updater methods are used to update column values in the
3782 * current row or the insert row. The updater methods do not
3783 * update the underlying database; instead the <code>updateRow</code> or
3784 * <code>insertRow</code> methods are called to update the database.
3785 *
3786 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3787 * it might be more efficient to use a version of
3788 * <code>updateAsciiStream</code> which takes a length parameter.
3789 *
3790 * @param columnIndex the first column is 1, the second is 2, ...
3791 * @param x the new column value
3792 * @exception SQLException if the columnIndex is not valid;
3793 * if a database access error occurs;
3794 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3795 * or this method is called on a closed result set
3796 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3797 * this method
3798 * @since 1.6
3799 */
3800 void updateAsciiStream(int columnIndex, java.io.InputStream x)
3801 throws SQLException;
3802
3803 /**
3804 * Updates the designated column with a binary stream value.
3805 * The data will be read from the stream
3806 * as needed until end-of-stream is reached.
3807 * <p>
3808 * The updater methods are used to update column values in the
3809 * current row or the insert row. The updater methods do not
3810 * update the underlying database; instead the <code>updateRow</code> or
3811 * <code>insertRow</code> methods are called to update the database.
3812 *
3813 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3814 * it might be more efficient to use a version of
3815 * <code>updateBinaryStream</code> which takes a length parameter.
3816 *
3817 * @param columnIndex the first column is 1, the second is 2, ...
3818 * @param x the new column value
3819 * @exception SQLException if the columnIndex is not valid;
3820 * if a database access error occurs;
3821 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3822 * or this method is called on a closed result set
3823 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3824 * this method
3825 * @since 1.6
3826 */
3827 void updateBinaryStream(int columnIndex, java.io.InputStream x)
3828 throws SQLException;
3829
3830 /**
3831 * Updates the designated column with a character stream value.
3832 * The data will be read from the stream
3833 * as needed until end-of-stream is reached.
3834 * <p>
3835 * The updater methods are used to update column values in the
3836 * current row or the insert row. The updater methods do not
3837 * update the underlying database; instead the <code>updateRow</code> or
3838 * <code>insertRow</code> methods are called to update the database.
3839 *
3840 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3841 * it might be more efficient to use a version of
3842 * <code>updateCharacterStream</code> which takes a length parameter.
3843 *
3844 * @param columnIndex the first column is 1, the second is 2, ...
3845 * @param x the new column value
3846 * @exception SQLException if the columnIndex is not valid;
3847 * if a database access error occurs;
3848 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3849 * or this method is called on a closed result set
3850 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3851 * this method
3852 * @since 1.6
3853 */
3854 void updateCharacterStream(int columnIndex, java.io.Reader x)
3855 throws SQLException;
3856
3857 /**
3858 * Updates the designated column with an ascii stream value.
3859 * The data will be read from the stream
3860 * as needed until end-of-stream is reached.
3861 * <p>
3862 * The updater methods are used to update column values in the
3863 * current row or the insert row. The updater methods do not
3864 * update the underlying database; instead the <code>updateRow</code> or
3865 * <code>insertRow</code> methods are called to update the database.
3866 *
3867 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3868 * it might be more efficient to use a version of
3869 * <code>updateAsciiStream</code> which takes a length parameter.
3870 *
3871 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3872 * @param x the new column value
3873 * @exception SQLException if the columnLabel is not valid;
3874 * if a database access error occurs;
3875 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3876 * or this method is called on a closed result set
3877 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3878 * this method
3879 * @since 1.6
3880 */
3881 void updateAsciiStream(String columnLabel, java.io.InputStream x)
3882 throws SQLException;
3883
3884 /**
3885 * Updates the designated column with a binary stream value.
3886 * The data will be read from the stream
3887 * as needed until end-of-stream is reached.
3888 * <p>
3889 * The updater methods are used to update column values in the
3890 * current row or the insert row. The updater methods do not
3891 * update the underlying database; instead the <code>updateRow</code> or
3892 * <code>insertRow</code> methods are called to update the database.
3893 *
3894 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3895 * it might be more efficient to use a version of
3896 * <code>updateBinaryStream</code> which takes a length parameter.
3897 *
3898 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3899 * @param x the new column value
3900 * @exception SQLException if the columnLabel is not valid;
3901 * if a database access error occurs;
3902 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3903 * or this method is called on a closed result set
3904 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3905 * this method
3906 * @since 1.6
3907 */
3908 void updateBinaryStream(String columnLabel, java.io.InputStream x)
3909 throws SQLException;
3910
3911 /**
3912 * Updates the designated column with a character stream value.
3913 * The data will be read from the stream
3914 * as needed until end-of-stream is reached.
3915 * <p>
3916 * The updater methods are used to update column values in the
3917 * current row or the insert row. The updater methods do not
3918 * update the underlying database; instead the <code>updateRow</code> or
3919 * <code>insertRow</code> methods are called to update the database.
3920 *
3921 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3922 * it might be more efficient to use a version of
3923 * <code>updateCharacterStream</code> which takes a length parameter.
3924 *
3925 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3926 * @param reader the <code>java.io.Reader</code> object containing
3927 * the new column value
3928 * @exception SQLException if the columnLabel is not valid; if a database access error occurs;
3929 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3930 * or this method is called on a closed result set
3931 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3932 * this method
3933 * @since 1.6
3934 */
3935 void updateCharacterStream(String columnLabel, java.io.Reader reader)
3936 throws SQLException;
3937
3938 /**
3939 * Updates the designated column using the given input stream. The data will be read from the stream
3940 * as needed until end-of-stream is reached.
3941 * <p>
3942 * The updater methods are used to update column values in the
3943 * current row or the insert row. The updater methods do not
3944 * update the underlying database; instead the <code>updateRow</code> or
3945 * <code>insertRow</code> methods are called to update the database.
3946 *
3947 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3948 * it might be more efficient to use a version of
3949 * <code>updateBlob</code> which takes a length parameter.
3950 *
3951 * @param columnIndex the first column is 1, the second is 2, ...
3952 * @param inputStream An object that contains the data to set the parameter
3953 * value to.
3954 * @exception SQLException if the columnIndex is not valid; if a database access error occurs;
3955 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3956 * or this method is called on a closed result set
3957 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3958 * this method
3959 * @since 1.6
3960 */
3961 void updateBlob(int columnIndex, InputStream inputStream)
3962 throws SQLException;
3963
3964 /**
3965 * Updates the designated column using the given input stream. The data will be read from the stream
3966 * as needed until end-of-stream is reached.
3967 * <p>
3968 * The updater methods are used to update column values in the
3969 * current row or the insert row. The updater methods do not
3970 * update the underlying database; instead the <code>updateRow</code> or
3971 * <code>insertRow</code> methods are called to update the database.
3972 *
3973 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3974 * it might be more efficient to use a version of
3975 * <code>updateBlob</code> which takes a length parameter.
3976 *
3977 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
3978 * @param inputStream An object that contains the data to set the parameter
3979 * value to.
3980 * @exception SQLException if the columnLabel is not valid; if a database access error occurs;
3981 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
3982 * or this method is called on a closed result set
3983 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3984 * this method
3985 * @since 1.6
3986 */
3987 void updateBlob(String columnLabel, InputStream inputStream)
3988 throws SQLException;
3989
3990 /**
3991 * Updates the designated column using the given <code>Reader</code>
3992 * object.
3993 * The data will be read from the stream
3994 * as needed until end-of-stream is reached. The JDBC driver will
3995 * do any necessary conversion from UNICODE to the database char format.
3996 *
3997 * <p>
3998 * The updater methods are used to update column values in the
3999 * current row or the insert row. The updater methods do not
4000 * update the underlying database; instead the <code>updateRow</code> or
4001 * <code>insertRow</code> methods are called to update the database.
4002 *
4003 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
4004 * it might be more efficient to use a version of
4005 * <code>updateClob</code> which takes a length parameter.
4006 *
4007 * @param columnIndex the first column is 1, the second is 2, ...
4008 * @param reader An object that contains the data to set the parameter value to.
4009 * @exception SQLException if the columnIndex is not valid;
4010 * if a database access error occurs;
4011 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
4012 * or this method is called on a closed result set
4013 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
4014 * this method
4015 * @since 1.6
4016 */
4017 void updateClob(int columnIndex, Reader reader) throws SQLException;
4018
4019 /**
4020 * Updates the designated column using the given <code>Reader</code>
4021 * object.
4022 * The data will be read from the stream
4023 * as needed until end-of-stream is reached. The JDBC driver will
4024 * do any necessary conversion from UNICODE to the database char format.
4025 *
4026 * <p>
4027 * The updater methods are used to update column values in the
4028 * current row or the insert row. The updater methods do not
4029 * update the underlying database; instead the <code>updateRow</code> or
4030 * <code>insertRow</code> methods are called to update the database.
4031 *
4032 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
4033 * it might be more efficient to use a version of
4034 * <code>updateClob</code> which takes a length parameter.
4035 *
4036 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
4037 * @param reader An object that contains the data to set the parameter value to.
4038 * @exception SQLException if the columnLabel is not valid; if a database access error occurs;
4039 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
4040 * or this method is called on a closed result set
4041 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
4042 * this method
4043 * @since 1.6
4044 */
4045 void updateClob(String columnLabel, Reader reader)
4046 throws SQLException;
4047
4048 /**
4049 * Updates the designated column using the given <code>Reader</code>
4050 *
4051 * The data will be read from the stream
4052 * as needed until end-of-stream is reached. The JDBC driver will
4053 * do any necessary conversion from UNICODE to the database char format.
4054 *
4055 * <p>
4056 * The updater methods are used to update column values in the
4057 * current row or the insert row. The updater methods do not
4058 * update the underlying database; instead the <code>updateRow</code> or
4059 * <code>insertRow</code> methods are called to update the database.
4060 *
4061 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
4062 * it might be more efficient to use a version of
4063 * <code>updateNClob</code> which takes a length parameter.
4064 *
4065 * @param columnIndex the first column is 1, the second 2, ...
4066 * @param reader An object that contains the data to set the parameter value to.
4067 * @throws SQLException if the columnIndex is not valid;
4068 * if the driver does not support national
4069 * character sets; if the driver can detect that a data conversion
4070 * error could occur; this method is called on a closed result set,
4071 * if a database access error occurs or
4072 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
4073 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
4074 * this method
4075 * @since 1.6
4076 */
4077 void updateNClob(int columnIndex, Reader reader)
4078 throws SQLException;
4079
4080 /**
4081 * Updates the designated column using the given <code>Reader</code>
4082 * object.
4083 * The data will be read from the stream
4084 * as needed until end-of-stream is reached. The JDBC driver will
4085 * do any necessary conversion from UNICODE to the database char format.
4086 *
4087 * <p>
4088 * The updater methods are used to update column values in the
4089 * current row or the insert row. The updater methods do not
4090 * update the underlying database; instead the <code>updateRow</code> or
4091 * <code>insertRow</code> methods are called to update the database.
4092 *
4093 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
4094 * it might be more efficient to use a version of
4095 * <code>updateNClob</code> which takes a length parameter.
4096 *
4097 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
4098 * @param reader An object that contains the data to set the parameter value to.
4099 * @throws SQLException if the columnLabel is not valid; if the driver does not support national
4100 * character sets; if the driver can detect that a data conversion
4101 * error could occur; this method is called on a closed result set;
4102 * if a database access error occurs or
4103 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
4104 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
4105 * this method
4106 * @since 1.6
4107 */
4108 void updateNClob(String columnLabel, Reader reader)
4109 throws SQLException;
4110
4111 }
|