Quelle ResultSet.java Sprache: JAVA

/*
* Copyright (c) 1996, 2020, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/

package java.sql;

import java.math.BigDecimal;
import java.util.Calendar;
import java.io.Reader;
import java.io.InputStream;

/**
* A table of data representing a database result set, which
* is usually generated by executing a statement that queries the database.
*
* A {@code ResultSet} object maintains a cursor pointing
* to its current row of data. Initially the cursor is positioned
* before the first row. The {@code next} method moves the
* cursor to the next row, and because it returns {@code false}
* when there are no more rows in the {@code ResultSet} object,
* it can be used in a {@code while} loop to iterate through
* the result set.
* 
* A default {@code ResultSet} object is not updatable and
* has a cursor that moves forward only. Thus, you can
* iterate through it only once and only from the first row to the
* last row. It is possible to
* produce {@code ResultSet} objects that are scrollable and/or
* updatable. The following code fragment, in which {@code con}
* is a valid {@code Connection} object, illustrates how to make
* a result set that is scrollable and insensitive to updates by others, and
* that is updatable. See {@code ResultSet} fields for other
* options.
* <PRE>
*
* Statement stmt = con.createStatement(
* ResultSet.TYPE_SCROLL_INSENSITIVE,
* ResultSet.CONCUR_UPDATABLE);
* ResultSet rs = stmt.executeQuery("SELECT a, b FROM TABLE2");
* // rs will be scrollable, will not show changes made by others,
* // and will be updatable
*
* </PRE>
* The {@code ResultSet} interface provides
* getter methods ({@code getBoolean}, {@code getLong}, and so on)
* for retrieving column values from the current row.
* Values can be retrieved using either the index number of the
* column or the name of the column. In general, using the
* column index will be more efficient. Columns are numbered from 1.
* For maximum portability, result set columns within each row should be
* read in left-to-right order, and each column should be read only once.
*
* For the getter methods, a JDBC driver attempts
* to convert the underlying data to the Java type specified in the
* getter method and returns a suitable Java value. The JDBC specification
* has a table showing the allowable mappings from SQL types to Java types
* that can be used by the {@code ResultSet} getter methods.
*
* Column names used as input to getter methods are case
* insensitive. When a getter method is called with
* a column name and several columns have the same name,
* the value of the first matching column will be returned.
* The column name option is
* designed to be used when column names are used in the SQL
* query that generated the result set.
* For columns that are NOT explicitly named in the query, it
* is best to use column numbers. If column names are used, the
* programmer should take care to guarantee that they uniquely refer to
* the intended columns, which can be assured with the SQL AS clause.
* 
* A set of updater methods were added to this interface
* in the JDBC 2.0 API (Java 2 SDK,
* Standard Edition, version 1.2). The comments regarding parameters
* to the getter methods also apply to parameters to the
* updater methods.
*
* The updater methods may be used in two ways:
* <ol>
* <LI>to update a column value in the current row. In a scrollable
* {@code ResultSet} object, the cursor can be moved backwards
* and forwards, to an absolute position, or to a position
* relative to the current row.
* The following code fragment updates the {@code NAME} column
* in the fifth row of the {@code ResultSet} object
* {@code rs} and then uses the method {@code updateRow}
* to update the data source table from which {@code rs} was derived.
* <PRE>
*
* rs.absolute(5); // moves the cursor to the fifth row of rs
* rs.updateString("NAME", "AINSWORTH"); // updates the
* // {@code NAME} column of row 5 to be {@code AINSWORTH}
* rs.updateRow(); // updates the row in the data source
*
* </PRE>
* <LI>to insert column values into the insert row. An updatable
* {@code ResultSet} object has a special row associated with
* it that serves as a staging area for building a row to be inserted.
* The following code fragment moves the cursor to the insert row, builds
* a three-column row, and inserts it into {@code rs} and into
* the data source table using the method {@code insertRow}.
* <PRE>
*
* rs.moveToInsertRow(); // moves cursor to the insert row
* rs.updateString(1, "AINSWORTH"); // updates the
* // first column of the insert row to be {@code AINSWORTH}
* rs.updateInt(2,35); // updates the second column to be {@code 35}
* rs.updateBoolean(3, true); // updates the third column to {@code true}
* rs.insertRow();
* rs.moveToCurrentRow();
*
* </PRE>
* </ol>
* A {@code ResultSet} object is automatically closed when the
* {@code Statement} object that
* generated it is closed, re-executed, or used
* to retrieve the next result from a sequence of multiple results.
*
* The number, types and properties of a {@code ResultSet}
* object's columns are provided by the {@code ResultSetMetaData}
* object returned by the {@code ResultSet.getMetaData} method.
*
* @see Statement#executeQuery
* @see Statement#getResultSet
* @see ResultSetMetaData
* @since 1.1
*/

public interface ResultSet extends Wrapper, AutoCloseable {

 /**
 * Moves the cursor forward one row from its current position.
 * A {@code ResultSet} cursor is initially positioned
 * before the first row; the first call to the method
 * {@code next} makes the first row the current row; the
 * second call makes the second row the current row, and so on.
 * 
 * When a call to the {@code next} method returns {@code false},
 * the cursor is positioned after the last row. Any
 * invocation of a {@code ResultSet} method which requires a
 * current row will result in a {@code SQLException} being thrown.
 * If the result set type is {@code TYPE_FORWARD_ONLY}, it is vendor specified
 * whether their JDBC driver implementation will return {@code false} or
 * throw an {@code SQLException} on a
 * subsequent call to {@code next}.
 *
 * If an input stream is open for the current row, a call
 * to the method {@code next} will
 * implicitly close it. A {@code ResultSet} object's
 * warning chain is cleared when a new row is read.
 *
 * @return {@code true} if the new current row is valid;
 * {@code false} if there are no more rows
 * @throws SQLException if a database access error occurs or this method is
 * called on a closed result set
 */
 boolean next() throws SQLException;

 /**
 * Releases this {@code ResultSet} object's database and
 * JDBC resources immediately instead of waiting for
 * this to happen when it is automatically closed.
 *
 * The closing of a {@code ResultSet} object does not close the {@code Blob},
 * {@code Clob} or {@code NClob} objects created by the {@code ResultSet}. {@code Blob},
 * {@code Clob} or {@code NClob} objects remain valid for at least the duration of the
 * transaction in which they are created, unless their {@code free} method is invoked.
 *
 * When a {@code ResultSet} is closed, any {@code ResultSetMetaData}
 * instances that were created by calling the {@code getMetaData}
 * method remain accessible.
 *
 * Note: A {@code ResultSet} object
 * is automatically closed by the
 * {@code Statement} object that generated it when
 * that {@code Statement} object is closed,
 * re-executed, or is used to retrieve the next result from a
 * sequence of multiple results.
 *
 * Calling the method {@code close} on a {@code ResultSet}
 * object that is already closed is a no-op.
 *
 *
 * @throws SQLException if a database access error occurs
 */
 void close() throws SQLException;

 /**
 * Reports whether
 * the last column read had a value of SQL {@code NULL}.
 * Note that you must first call one of the getter methods
 * on a column to try to read its value and then call
 * the method {@code wasNull} to see if the value read was
 * SQL {@code NULL}.
 *
 * @return {@code true} if the last column value read was SQL
 * {@code NULL} and {@code false} otherwise
 * @throws SQLException if a database access error occurs or this method is
 * called on a closed result set
 */
 boolean wasNull() throws SQLException;

 // Methods for accessing results by column index

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * a {@code String} in the Java programming language.
 *
 * @param columnIndex the first column is 1, the second is 2, ...
 * @return the column value; if the value is SQL {@code NULL}, the
 * value returned is {@code null}
 * @throws SQLException if the columnIndex is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 String getString(int columnIndex) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * a {@code boolean} in the Java programming language.
 *
 * If the designated column has a datatype of CHAR or VARCHAR
 * and contains a "0" or has a datatype of BIT, TINYINT, SMALLINT, INTEGER or BIGINT
 * and contains a 0, a value of {@code false} is returned. If the designated column has a datatype
 * of CHAR or VARCHAR
 * and contains a "1" or has a datatype of BIT, TINYINT, SMALLINT, INTEGER or BIGINT
 * and contains a 1, a value of {@code true} is returned.
 *
 * @param columnIndex the first column is 1, the second is 2, ...
 * @return the column value; if the value is SQL {@code NULL}, the
 * value returned is {@code false}
 * @throws SQLException if the columnIndex is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 boolean getBoolean(int columnIndex) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * a {@code byte} in the Java programming language.
 *
 * @param columnIndex the first column is 1, the second is 2, ...
 * @return the column value; if the value is SQL {@code NULL}, the
 * value returned is {@code 0}
 * @throws SQLException if the columnIndex is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 byte getByte(int columnIndex) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * a {@code short} in the Java programming language.
 *
 * @param columnIndex the first column is 1, the second is 2, ...
 * @return the column value; if the value is SQL {@code NULL}, the
 * value returned is {@code 0}
 * @throws SQLException if the columnIndex is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 short getShort(int columnIndex) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * an {@code int} in the Java programming language.
 *
 * @param columnIndex the first column is 1, the second is 2, ...
 * @return the column value; if the value is SQL {@code NULL}, the
 * value returned is {@code 0}
 * @throws SQLException if the columnIndex is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 int getInt(int columnIndex) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * a {@code long} in the Java programming language.
 *
 * @param columnIndex the first column is 1, the second is 2, ...
 * @return the column value; if the value is SQL {@code NULL}, the
 * value returned is {@code 0}
 * @throws SQLException if the columnIndex is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 long getLong(int columnIndex) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * a {@code float} in the Java programming language.
 *
 * @param columnIndex the first column is 1, the second is 2, ...
 * @return the column value; if the value is SQL {@code NULL}, the
 * value returned is {@code 0}
 * @throws SQLException if the columnIndex is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 float getFloat(int columnIndex) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * a {@code double} in the Java programming language.
 *
 * @param columnIndex the first column is 1, the second is 2, ...
 * @return the column value; if the value is SQL {@code NULL}, the
 * value returned is {@code 0}
 * @throws SQLException if the columnIndex is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 double getDouble(int columnIndex) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * a {@code java.sql.BigDecimal} in the Java programming language.
 *
 * @param columnIndex the first column is 1, the second is 2, ...
 * @param scale the number of digits to the right of the decimal point
 * @return the column value; if the value is SQL {@code NULL}, the
 * value returned is {@code null}
 * @throws SQLException if the columnIndex is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
 * this method
 * @deprecated Use {@code getBigDecimal(int columnIndex)}
 * or {@code getBigDecimal(String columnLabel)}
 */
 @Deprecated(since="1.2")
 BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * a {@code byte} array in the Java programming language.
 * The bytes represent the raw values returned by the driver.
 *
 * @param columnIndex the first column is 1, the second is 2, ...
 * @return the column value; if the value is SQL {@code NULL}, the
 * value returned is {@code null}
 * @throws SQLException if the columnIndex is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 byte[] getBytes(int columnIndex) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * a {@code java.sql.Date} object in the Java programming language.
 *
 * @param columnIndex the first column is 1, the second is 2, ...
 * @return the column value; if the value is SQL {@code NULL}, the
 * value returned is {@code null}
 * @throws SQLException if the columnIndex is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 java.sql.Date getDate(int columnIndex) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * a {@code java.sql.Time} object in the Java programming language.
 *
 * @param columnIndex the first column is 1, the second is 2, ...
 * @return the column value; if the value is SQL {@code NULL}, the
 * value returned is {@code null}
 * @throws SQLException if the columnIndex is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 java.sql.Time getTime(int columnIndex) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * a {@code java.sql.Timestamp} object in the Java programming language.
 *
 * @param columnIndex the first column is 1, the second is 2, ...
 * @return the column value; if the value is SQL {@code NULL}, the
 * value returned is {@code null}
 * @throws SQLException if the columnIndex is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 java.sql.Timestamp getTimestamp(int columnIndex) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * a stream of ASCII characters. The value can then be read in chunks from the
 * stream. This method is particularly
 * suitable for retrieving large {@code LONGVARCHAR} values.
 * The JDBC driver will
 * do any necessary conversion from the database format into ASCII.
 *
 * Note: All the data in the returned stream must be
 * read prior to getting the value of any other column. The next
 * call to a getter method implicitly closes the stream. Also, a
 * stream may return {@code 0} when the method
 * {@code InputStream.available}
 * is called whether there is data available or not.
 *
 * @param columnIndex the first column is 1, the second is 2, ...
 * @return a Java input stream that delivers the database column value
 * as a stream of one-byte ASCII characters;
 * if the value is SQL {@code NULL}, the
 * value returned is {@code null}
 * @throws SQLException if the columnIndex is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 java.io.InputStream getAsciiStream(int columnIndex) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * as a stream of two-byte 3 characters. The first byte is
 * the high byte; the second byte is the low byte.
 *
 * The value can then be read in chunks from the
 * stream. This method is particularly
 * suitable for retrieving large {@code LONGVARCHAR}values. The
 * JDBC driver will do any necessary conversion from the database
 * format into Unicode.
 *
 * Note: All the data in the returned stream must be
 * read prior to getting the value of any other column. The next
 * call to a getter method implicitly closes the stream.
 * Also, a stream may return {@code 0} when the method
 * {@code InputStream.available}
 * is called, whether there is data available or not.
 *
 * @param columnIndex the first column is 1, the second is 2, ...
 * @return a Java input stream that delivers the database column value
 * as a stream of two-byte Unicode characters;
 * if the value is SQL {@code NULL}, the value returned is
 * {@code null}
 *
 * @throws SQLException if the columnIndex is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
 * this method
 * @deprecated use {@code getCharacterStream} in place of
 * {@code getUnicodeStream}
 */
 @Deprecated(since="1.2")
 java.io.InputStream getUnicodeStream(int columnIndex) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as a stream of
 * uninterpreted bytes. The value can then be read in chunks from the
 * stream. This method is particularly
 * suitable for retrieving large {@code LONGVARBINARY} values.
 *
 * Note: All the data in the returned stream must be
 * read prior to getting the value of any other column. The next
 * call to a getter method implicitly closes the stream. Also, a
 * stream may return {@code 0} when the method
 * {@code InputStream.available}
 * is called whether there is data available or not.
 *
 * @param columnIndex the first column is 1, the second is 2, ...
 * @return a Java input stream that delivers the database column value
 * as a stream of uninterpreted bytes;
 * if the value is SQL {@code NULL}, the value returned is
 * {@code null}
 * @throws SQLException if the columnIndex is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 java.io.InputStream getBinaryStream(int columnIndex)
 throws SQLException;

 // Methods for accessing results by column label

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * a {@code String} in the Java programming language.
 *
 * @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
 * @return the column value; if the value is SQL {@code NULL}, the
 * value returned is {@code null}
 * @throws SQLException if the columnLabel is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 String getString(String columnLabel) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * a {@code boolean} in the Java programming language.
 *
 * If the designated column has a datatype of CHAR or VARCHAR
 * and contains a "0" or has a datatype of BIT, TINYINT, SMALLINT, INTEGER or BIGINT
 * and contains a 0, a value of {@code false} is returned. If the designated column has a datatype
 * of CHAR or VARCHAR
 * and contains a "1" or has a datatype of BIT, TINYINT, SMALLINT, INTEGER or BIGINT
 * and contains a 1, a value of {@code true} is returned.
 *
 * @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
 * @return the column value; if the value is SQL {@code NULL}, the
 * value returned is {@code false}
 * @throws SQLException if the columnLabel is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 boolean getBoolean(String columnLabel) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * a {@code byte} in the Java programming language.
 *
 * @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
 * @return the column value; if the value is SQL {@code NULL}, the
 * value returned is {@code 0}
 * @throws SQLException if the columnLabel is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 byte getByte(String columnLabel) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * a {@code short} in the Java programming language.
 *
 * @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
 * @return the column value; if the value is SQL {@code NULL}, the
 * value returned is {@code 0}
 * @throws SQLException if the columnLabel is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 short getShort(String columnLabel) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * an {@code int} in the Java programming language.
 *
 * @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
 * @return the column value; if the value is SQL {@code NULL}, the
 * value returned is {@code 0}
 * @throws SQLException if the columnLabel is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 int getInt(String columnLabel) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * a {@code long} in the Java programming language.
 *
 * @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
 * @return the column value; if the value is SQL {@code NULL}, the
 * value returned is {@code 0}
 * @throws SQLException if the columnLabel is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 long getLong(String columnLabel) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * a {@code float} in the Java programming language.
 *
 * @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
 * @return the column value; if the value is SQL {@code NULL}, the
 * value returned is {@code 0}
 * @throws SQLException if the columnLabel is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 float getFloat(String columnLabel) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * a {@code double} in the Java programming language.
 *
 * @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
 * @return the column value; if the value is SQL {@code NULL}, the
 * value returned is {@code 0}
 * @throws SQLException if the columnLabel is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 double getDouble(String columnLabel) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * a {@code java.math.BigDecimal} in the Java programming language.
 *
 * @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
 * @param scale the number of digits to the right of the decimal point
 * @return the column value; if the value is SQL {@code NULL}, the
 * value returned is {@code null}
 * @throws SQLException if the columnLabel is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
 * this method
 * @deprecated Use {@code getBigDecimal(int columnIndex)}
 * or {@code getBigDecimal(String columnLabel)}
 */
 @Deprecated(since="1.2")
 BigDecimal getBigDecimal(String columnLabel, int scale) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * a {@code byte} array in the Java programming language.
 * The bytes represent the raw values returned by the driver.
 *
 * @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
 * @return the column value; if the value is SQL {@code NULL}, the
 * value returned is {@code null}
 * @throws SQLException if the columnLabel is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 byte[] getBytes(String columnLabel) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * a {@code java.sql.Date} object in the Java programming language.
 *
 * @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
 * @return the column value; if the value is SQL {@code NULL}, the
 * value returned is {@code null}
 * @throws SQLException if the columnLabel is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 java.sql.Date getDate(String columnLabel) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * a {@code java.sql.Time} object in the Java programming language.
 *
 * @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
 * @return the column value;
 * if the value is SQL {@code NULL},
 * the value returned is {@code null}
 * @throws SQLException if the columnLabel is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 java.sql.Time getTime(String columnLabel) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * a {@code java.sql.Timestamp} object in the Java programming language.
 *
 * @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
 * @return the column value; if the value is SQL {@code NULL}, the
 * value returned is {@code null}
 * @throws SQLException if the columnLabel is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 java.sql.Timestamp getTimestamp(String columnLabel) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as a stream of
 * ASCII characters. The value can then be read in chunks from the
 * stream. This method is particularly
 * suitable for retrieving large {@code LONGVARCHAR} values.
 * The JDBC driver will
 * do any necessary conversion from the database format into ASCII.
 *
 * Note: All the data in the returned stream must be
 * read prior to getting the value of any other column. The next
 * call to a getter method implicitly closes the stream. Also, a
 * stream may return {@code 0} when the method {@code available}
 * is called whether there is data available or not.
 *
 * @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
 * @return a Java input stream that delivers the database column value
 * as a stream of one-byte ASCII characters.
 * If the value is SQL {@code NULL},
 * the value returned is {@code null}.
 * @throws SQLException if the columnLabel is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 java.io.InputStream getAsciiStream(String columnLabel) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as a stream of two-byte
 * Unicode characters. The first byte is the high byte; the second
 * byte is the low byte.
 *
 * The value can then be read in chunks from the
 * stream. This method is particularly
 * suitable for retrieving large {@code LONGVARCHAR} values.
 * The JDBC technology-enabled driver will
 * do any necessary conversion from the database format into Unicode.
 *
 * Note: All the data in the returned stream must be
 * read prior to getting the value of any other column. The next
 * call to a getter method implicitly closes the stream.
 * Also, a stream may return {@code 0} when the method
 * {@code InputStream.available} is called, whether there
 * is data available or not.
 *
 * @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
 * @return a Java input stream that delivers the database column value
 * as a stream of two-byte Unicode characters.
 * If the value is SQL {@code NULL}, the value returned
 * is {@code null}.
 * @throws SQLException if the columnLabel is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
 * this method
 * @deprecated use {@code getCharacterStream} instead
 */
 @Deprecated(since="1.2")
 java.io.InputStream getUnicodeStream(String columnLabel) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as a stream of uninterpreted
 * {@code byte}s.
 * The value can then be read in chunks from the
 * stream. This method is particularly
 * suitable for retrieving large {@code LONGVARBINARY}
 * values.
 *
 * Note: All the data in the returned stream must be
 * read prior to getting the value of any other column. The next
 * call to a getter method implicitly closes the stream. Also, a
 * stream may return {@code 0} when the method {@code available}
 * is called whether there is data available or not.
 *
 * @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
 * @return a Java input stream that delivers the database column value
 * as a stream of uninterpreted bytes;
 * if the value is SQL {@code NULL}, the result is {@code null}
 * @throws SQLException if the columnLabel is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 java.io.InputStream getBinaryStream(String columnLabel)
 throws SQLException;

 // Advanced features:

 /**
 * Retrieves the first warning reported by calls on this
 * {@code ResultSet} object.
 * Subsequent warnings on this {@code ResultSet} object
 * will be chained to the {@code SQLWarning} object that
 * this method returns.
 *
 * The warning chain is automatically cleared each time a new
 * row is read. This method may not be called on a {@code ResultSet}
 * object that has been closed; doing so will cause an
 * {@code SQLException} to be thrown.
 * 
 * Note: This warning chain only covers warnings caused
 * by {@code ResultSet} methods. Any warning caused by
 * {@code Statement} methods
 * (such as reading OUT parameters) will be chained on the
 * {@code Statement} object.
 *
 * @return the first {@code SQLWarning} object reported or
 * {@code null} if there are none
 * @throws SQLException if a database access error occurs or this method is
 * called on a closed result set
 */
 SQLWarning getWarnings() throws SQLException;

 /**
 * Clears all warnings reported on this {@code ResultSet} object.
 * After this method is called, the method {@code getWarnings}
 * returns {@code null} until a new warning is
 * reported for this {@code ResultSet} object.
 *
 * @throws SQLException if a database access error occurs or this method is
 * called on a closed result set
 */
 void clearWarnings() throws SQLException;

 /**
 * Retrieves the name of the SQL cursor used by this {@code ResultSet}
 * object.
 *
 * In SQL, a result table is retrieved through a cursor that is
 * named. The current row of a result set can be updated or deleted
 * using a positioned update/delete statement that references the
 * cursor name. To insure that the cursor has the proper isolation
 * level to support update, the cursor's {@code SELECT} statement
 * should be of the form {@code SELECT FOR UPDATE}. If
 * {@code FOR UPDATE} is omitted, the positioned updates may fail.
 *
 * The JDBC API supports this SQL feature by providing the name of the
 * SQL cursor used by a {@code ResultSet} object.
 * The current row of a {@code ResultSet} object
 * is also the current row of this SQL cursor.
 *
 * @return the SQL name for this {@code ResultSet} object's cursor
 * @throws SQLException if a database access error occurs or this method is called on a closed result set
 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
 * this method
 */
 String getCursorName() throws SQLException;

 /**
 * Retrieves the number, types and properties of
 * this {@code ResultSet} object's columns.
 *
 * @return the description of this {@code ResultSet} object's columns
 * @throws SQLException if a database access error occurs or this method is
 * called on a closed result set
 */
 ResultSetMetaData getMetaData() throws SQLException;

 /**
 * Gets the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * an {@code Object} in the Java programming language.
 *
 * This method will return the value of the given column as a
 * Java object. The type of the Java object will be the default
 * Java object type corresponding to the column's SQL type,
 * following the mapping for built-in types specified in the JDBC
 * specification. If the value is an SQL {@code NULL},
 * the driver returns a Java {@code null}.
 *
 * This method may also be used to read database-specific
 * abstract data types.
 *
 * In the JDBC 2.0 API, the behavior of method
 * {@code getObject} is extended to materialize
 * data of SQL user-defined types.
 * 
 * If {@code Connection.getTypeMap} does not throw a
 * {@code SQLFeatureNotSupportedException},
 * then when a column contains a structured or distinct value,
 * the behavior of this method is as
 * if it were a call to: {@code getObject(columnIndex,
 * this.getStatement().getConnection().getTypeMap())}.
 *
 * If {@code Connection.getTypeMap} does throw a
 * {@code SQLFeatureNotSupportedException},
 * then structured values are not supported, and distinct values
 * are mapped to the default Java class as determined by the
 * underlying SQL type of the DISTINCT type.
 *
 * @param columnIndex the first column is 1, the second is 2, ...
 * @return a {@code java.lang.Object} holding the column value
 * @throws SQLException if the columnIndex is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 Object getObject(int columnIndex) throws SQLException;

 /**
 * Gets the value of the designated column in the current row
 * of this {@code ResultSet} object as
 * an {@code Object} in the Java programming language.
 *
 * This method will return the value of the given column as a
 * Java object. The type of the Java object will be the default
 * Java object type corresponding to the column's SQL type,
 * following the mapping for built-in types specified in the JDBC
 * specification. If the value is an SQL {@code NULL},
 * the driver returns a Java {@code null}.
 * 
 * This method may also be used to read database-specific
 * abstract data types.
 * 
 * In the JDBC 2.0 API, the behavior of the method
 * {@code getObject} is extended to materialize
 * data of SQL user-defined types. When a column contains
 * a structured or distinct value, the behavior of this method is as
 * if it were a call to: {@code getObject(columnIndex,
 * this.getStatement().getConnection().getTypeMap())}.
 *
 * @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
 * @return a {@code java.lang.Object} holding the column value
 * @throws SQLException if the columnLabel is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 */
 Object getObject(String columnLabel) throws SQLException;

 //----------------------------------------------------------------

 /**
 * Maps the given {@code ResultSet} column label to its
 * {@code ResultSet} column index.
 *
 * @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
 * @return the column index of the given column name
 * @throws SQLException if the {@code ResultSet} object
 * does not contain a column labeled {@code columnLabel}, a database access error occurs
 * or this method is called on a closed result set
 */
 int findColumn(String columnLabel) throws SQLException;

 //--------------------------JDBC 2.0-----------------------------------

 //---------------------------------------------------------------------
 // Getters and Setters
 //---------------------------------------------------------------------

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as a
 * {@code java.io.Reader} object.
 * @return a {@code java.io.Reader} object that contains the column
 * value; if the value is SQL {@code NULL}, the value returned is
 * {@code null} in the Java programming language.
 * @param columnIndex the first column is 1, the second is 2, ...
 * @throws SQLException if the columnIndex is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 * @since 1.2
 */
 java.io.Reader getCharacterStream(int columnIndex) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as a
 * {@code java.io.Reader} object.
 *
 * @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
 * @return a {@code java.io.Reader} object that contains the column
 * value; if the value is SQL {@code NULL}, the value returned is
 * {@code null} in the Java programming language
 * @throws SQLException if the columnLabel is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 * @since 1.2
 */
 java.io.Reader getCharacterStream(String columnLabel) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as a
 * {@code java.math.BigDecimal} with full precision.
 *
 * @param columnIndex the first column is 1, the second is 2, ...
 * @return the column value (full precision);
 * if the value is SQL {@code NULL}, the value returned is
 * {@code null} in the Java programming language.
 * @throws SQLException if the columnIndex is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 * @since 1.2
 */
 BigDecimal getBigDecimal(int columnIndex) throws SQLException;

 /**
 * Retrieves the value of the designated column in the current row
 * of this {@code ResultSet} object as a
 * {@code java.math.BigDecimal} with full precision.
 *
 * @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
 * @return the column value (full precision);
 * if the value is SQL {@code NULL}, the value returned is
 * {@code null} in the Java programming language.
 * @throws SQLException if the columnLabel is not valid;
 * if a database access error occurs or this method is
 * called on a closed result set
 * @since 1.2
 *
 */
 BigDecimal getBigDecimal(String columnLabel) throws SQLException;

 //---------------------------------------------------------------------
 // Traversal/Positioning
 //---------------------------------------------------------------------

 /**
 * Retrieves whether the cursor is before the first row in
 * this {@code ResultSet} object.
 * 
 * Note:Support for the {@code isBeforeFirst} method
 * is optional for {@code ResultSet}s with a result
 * set type of {@code TYPE_FORWARD_ONLY}
 *
 * @return {@code true} if the cursor is before the first row;
 * {@code false} if the cursor is at any other position or the
 * result set contains no rows
 * @throws SQLException if a database access error occurs or this method is
 * called on a closed result set
 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
 * this method
 * @since 1.2
 */
 boolean isBeforeFirst() throws SQLException;

 /**
 * Retrieves whether the cursor is after the last row in
 * this {@code ResultSet} object.
 * 
 * Note:Support for the {@code isAfterLast} method
 * is optional for {@code ResultSet}s with a result
 * set type of {@code TYPE_FORWARD_ONLY}
 *
 * @return {@code true} if the cursor is after the last row;
 * {@code false} if the cursor is at any other position or the
 * result set contains no rows
 * @throws SQLException if a database access error occurs or this method is
 * called on a closed result set
 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
 * this method
 * @since 1.2
 */
 boolean isAfterLast() throws SQLException;

 /**
 * Retrieves whether the cursor is on the first row of
 * this {@code ResultSet} object.
 * 
 * Note:Support for the {@code isFirst} method
 * is optional for {@code ResultSet}s with a result
 * set type of {@code TYPE_FORWARD_ONLY}
 *
 * @return {@code true} if the cursor is on the first row;
 * {@code false} otherwise
 * @throws SQLException if a database access error occurs or this method is
 * called on a closed result set
 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
 * this method
 * @since 1.2
 */
 boolean isFirst() throws SQLException;

 /**
 * Retrieves whether the cursor is on the last row of
 * this {@code ResultSet} object.
 * Note: Calling the method {@code isLast} may be expensive
 * because the JDBC driver
 * might need to fetch ahead one row in order to determine
 * whether the current row is the last row in the result set.
 * 
 * Note: Support for the {@code isLast} method
 * is optional for {@code ResultSet}s with a result
 * set type of {@code TYPE_FORWARD_ONLY}
 * @return {@code true} if the cursor is on the last row;
 * {@code false} otherwise
 * @throws SQLException if a database access error occurs or this method is
 * called on a closed result set
 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
 * this method
 * @since 1.2
 */
 boolean isLast() throws SQLException;

 /**
 * Moves the cursor to the front of
 * this {@code ResultSet} object, just before the
 * first row. This method has no effect if the result set contains no rows.
 *
 * @throws SQLException if a database access error
 * occurs; this method is called on a closed result set or the
 * result set type is {@code TYPE_FORWARD_ONLY}
 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
 * this method
 * @since 1.2
 */
 void beforeFirst() throws SQLException;

 /**
 * Moves the cursor to the end of
 * this {@code ResultSet} object, just after the
 * last row. This method has no effect if the result set contains no rows.
 * @throws SQLException if a database access error
 * occurs; this method is called on a closed result set
 * or the result set type is {@code TYPE_FORWARD_ONLY}
 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
 * this method
 * @since 1.2
 */
 void afterLast() throws SQLException;

 /**
 * Moves the cursor to the first row in
 * this {@code ResultSet} object.
 *
 * @return {@code true} if the cursor is on a valid row;
 * {@code false} if there are no rows in the result set
 * @throws SQLException if a database access error
 * occurs; this method is called on a closed result set
 * or the result set type is {@code TYPE_FORWARD_ONLY}
 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
 * this method
 * @since 1.2
 */
 boolean first() throws SQLException;

 /**
 * Moves the cursor to the last row in
 * this {@code ResultSet} object.
 *
 * @return {@code true} if the cursor is on a valid row;
 * {@code false} if there are no rows in the result set
 * @throws SQLException if a database access error
 * occurs; this method is called on a closed result set
 * or the result set type is {@code TYPE_FORWARD_ONLY}
 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
 * this method
 * @since 1.2
 */
 boolean last() throws SQLException;

 /**
 * Retrieves the current row number. The first row is number 1, the
 * second number 2, and so on.
 * 
 * Note:Support for the {@code getRow} method
 * is optional for {@code ResultSet}s with a result
 * set type of {@code TYPE_FORWARD_ONLY}
 *
 * @return the current row number; {@code 0} if there is no current row
 * @throws SQLException if a database access error occurs
 * or this method is called on a closed result set
 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
 * this method
 * @since 1.2
 */
 int getRow() throws SQLException;

 /**
 * Moves the cursor to the given row number in
 * this {@code ResultSet} object.
 *
 * If the row number is positive, the cursor moves to
 * the given row number with respect to the
 * beginning of the result set. The first row is row 1, the second
 * is row 2, and so on.
 *
 * If the given row number is negative, the cursor moves to
 * an absolute row position with respect to
 * the end of the result set. For example, calling the method
 * {@code absolute(-1)} positions the
 * cursor on the last row; calling the method {@code absolute(-2)}
 * moves the cursor to the next-to-last row, and so on.
 *
 * If the row number specified is zero, the cursor is moved to
 * before the first row.
 *
 * An attempt to position the cursor beyond the first/last row in
 * the result set leaves the cursor before the first row or after
 * the last row.
 *
 * Note: Calling {@code absolute(1)} is the same
 * as calling {@code first()}. Calling {@code absolute(-1)}
 * is the same as calling {@code last()}.
 *
 * @param row the number of the row to which the cursor should move.
 * A value of zero indicates that the cursor will be positioned
 * before the first row; a positive number indicates the row number
 * counting from the beginning of the result set; a negative number
 * indicates the row number counting from the end of the result set
 * @return {@code true} if the cursor is moved to a position in this
 * {@code ResultSet} object;
 * {@code false} if the cursor is before the first row or after the
 * last row
 * @throws SQLException if a database access error
 * occurs; this method is called on a closed result set
 * or the result set type is {@code TYPE_FORWARD_ONLY}
 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
 * this method
 * @since 1.2
 */
 boolean absolute( int row ) throws SQLException;

 /**
 * Moves the cursor a relative number of rows, either positive or negative.
 * Attempting to move beyond the first/last row in the
 * result set positions the cursor before/after the
 * the first/last row. Calling {@code relative(0)} is valid, but does
 * not change the cursor position.
 *
 * Note: Calling the method {@code relative(1)}
 * is identical to calling the method {@code next()} and
 * calling the method {@code relative(-1)} is identical
 * to calling the method {@code previous()}.
 *
 * @param rows an {@code int} specifying the number of rows to
 * move from the current row; a positive number moves the cursor
 * forward; a negative number moves the cursor backward
 * @return {@code true} if the cursor is on a row;
 * {@code false} otherwise
 * @throws SQLException if a database access error occurs; this method
 * is called on a closed result set or the result set type is
 * {@code TYPE_FORWARD_ONLY}
 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
 * this method
 * @since 1.2
 */
 boolean relative( int rows ) throws SQLException;

 /**
 * Moves the cursor to the previous row in this
 * {@code ResultSet} object.
 *
 * When a call to the {@code previous} method returns {@code false},
 * the cursor is positioned before the first row. Any invocation of a
 * {@code ResultSet} method which requires a current row will result in a
 * {@code SQLException} being thrown.
 *
 * If an input stream is open for the current row, a call to the method
 * {@code previous} will implicitly close it. A {@code ResultSet}
 * object's warning change is cleared when a new row is read.
 *
 * @return {@code true} if the cursor is now positioned on a valid row;
 * {@code false} if the cursor is positioned before the first row
 * @throws SQLException if a database access error
 * occurs; this method is called on a closed result set
 * or the result set type is {@code TYPE_FORWARD_ONLY}
 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
 * this method
 * @since 1.2
 */
 boolean previous() throws SQLException;

 //---------------------------------------------------------------------
 // Properties
 //---------------------------------------------------------------------

 /**
 * The constant indicating that the rows in a result set will be
 * processed in a forward direction; first-to-last.
 * This constant is used by the method {@code setFetchDirection}
 * as a hint to the driver, which the driver may ignore.
 * @since 1.2
 */
 int FETCH_FORWARD = 1000;

 /**
 * The constant indicating that the rows in a result set will be
 * processed in a reverse direction; last-to-first.
 * This constant is used by the method {@code setFetchDirection}
 * as a hint to the driver, which the driver may ignore.
 * @since 1.2
 */
 int FETCH_REVERSE = 1001;

 /**
 * The constant indicating that the order in which rows in a
 * result set will be processed is unknown.
 * This constant is used by the method {@code setFetchDirection}
 * as a hint to the driver, which the driver may ignore.
 */
 int FETCH_UNKNOWN = 1002;

 /**
 * Gives a hint as to the direction in which the rows in this
 * {@code ResultSet} object will be processed.
 * The initial value is determined by the
 * {@code Statement} object
 * that produced this {@code ResultSet} object.
 * The fetch direction may be changed at any time.
 *
 * @param direction an {@code int} specifying the suggested
 * fetch direction; one of {@code ResultSet.FETCH_FORWARD},
 * {@code ResultSet.FETCH_REVERSE}, or
 * {@code ResultSet.FETCH_UNKNOWN}
 * @throws SQLException if a database access error occurs; this
 * method is called on a closed result set or
 * the result set type is {@code TYPE_FORWARD_ONLY} and the fetch
 * direction is not {@code FETCH_FORWARD}
 * @since 1.2
 * @see Statement#setFetchDirection
 * @see #getFetchDirection
 */
 void setFetchDirection(int direction) throws SQLException;

 /**
 * Retrieves the fetch direction for this
 * {@code ResultSet} object.
 *
 * @return the current fetch direction for this {@code ResultSet} object
 * @throws SQLException if a database access error occurs
 * or this method is called on a closed result set
 * @since 1.2
 * @see #setFetchDirection
 */
 int getFetchDirection() throws SQLException;

 /**
 * Gives the JDBC driver a hint as to the number of rows that should
 * be fetched from the database when more rows are needed for this
 * {@code ResultSet} object.
 * If the fetch size specified is zero, the JDBC driver
 * ignores the value and is free to make its own best guess as to what
 * the fetch size should be. The default value is set by the
 * {@code Statement} object
 * that created the result set. The fetch size may be changed at any time.
 *
 * @param rows the number of rows to fetch
 * @throws SQLException if a database access error occurs; this method
 * is called on a closed result set or the
 * condition {@code rows >= 0} is not satisfied
 * @since 1.2
 * @see #getFetchSize
 */
 void setFetchSize(int rows) throws SQLException;

 /**
 * Retrieves the fetch size for this
 * {@code ResultSet} object.
 *
 * @return the current fetch size for this {@code ResultSet} object
 * @throws SQLException if a database access error occurs
 * or this method is called on a closed result set
 * @since 1.2
 * @see #setFetchSize
 */
 int getFetchSize() throws SQLException;

 /**
 * The constant indicating the type for a {@code ResultSet} object
 * whose cursor may move only forward.
 * @since 1.2
 */
 int TYPE_FORWARD_ONLY = 1003;

 /**
 * The constant indicating the type for a {@code ResultSet} object
 * that is scrollable but generally not sensitive to changes to the data
 * that underlies the {@code ResultSet}.
 * @since 1.2
 */
 int TYPE_SCROLL_INSENSITIVE = 1004;

 /**
 * The constant indicating the type for a {@code ResultSet} object
 * that is scrollable and generally sensitive to changes to the data
 * that underlies the {@code ResultSet}.
 * @since 1.2
 */
 int TYPE_SCROLL_SENSITIVE = 1005;

 /**
 * Retrieves the type of this {@code ResultSet} object.
 * The type is determined by the {@code Statement} object
 * that created the result set.
 *
 * @return {@code ResultSet.TYPE_FORWARD_ONLY},
 * {@code ResultSet.TYPE_SCROLL_INSENSITIVE},
 * or {@code ResultSet.TYPE_SCROLL_SENSITIVE}
 * @throws SQLException if a database access error occurs
 * or this method is called on a closed result set
 * @since 1.2
 */
 int getType() throws SQLException;

 /**
 * The constant indicating the concurrency mode for a
 * {@code ResultSet} object that may NOT be updated.
 * @since 1.2
 */
 int CONCUR_READ_ONLY = 1007;

 /**
 * The constant indicating the concurrency mode for a
 * {@code ResultSet} object that may be updated.
 * @since 1.2
 */
 int CONCUR_UPDATABLE = 1008;

 /**
 * Retrieves the concurrency mode of this {@code ResultSet} object.
 * The concurrency used is determined by the
 * {@code Statement} object that created the result set.
 *
 * @return the concurrency type, either
 * {@code ResultSet.CONCUR_READ_ONLY}
 * or {@code ResultSet.CONCUR_UPDATABLE}
 * @throws SQLException if a database access error occurs
 * or this method is called on a closed result set
 * @since 1.2
 */
 int getConcurrency() throws SQLException;

 //---------------------------------------------------------------------
 // Updates
 //---------------------------------------------------------------------

 /**
 * Retrieves whether the current row has been updated. The value returned
 * depends on whether or not the result set can detect updates.
 * 
 * Note: Support for the {@code rowUpdated} method is optional with a result set
 * concurrency of {@code CONCUR_READ_ONLY}
 * @return {@code true} if the current row is detected to
 * have been visibly updated by the owner or another; {@code false} otherwise
 * @throws SQLException if a database access error occurs
 * or this method is called on a closed result set
 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
 * this method
 * @see DatabaseMetaData#updatesAreDetected
 * @since 1.2
 */
 boolean rowUpdated() throws SQLException;

 /**
 * Retrieves whether the current row has had an insertion.
 * The value returned depends on whether or not this
 * {@code ResultSet} object can detect visible inserts.
--> --------------------

--> maximum size reached

--> --------------------

Messung V0.5

¤ Dauer der Verarbeitung: 0.10 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.