*/    public boolean relative(int rows) throws SQLException {        checkState();         boolean b = rs.relative(rows);        notifyCursorMoved();        return b;    }     /**     * Moves the cursor to the previous row in this     * <code>ResultSet</code> object.     *     * <p><B>Note:</B> Calling the method <code>previous()</code> is not the same as     * calling the method <code>relative(-1)</code> because it     * makes sense to call <code>previous()</code> when there is no current row.     *     * @return <code>true</code> if the cursor is on a valid row;     * <code>false</code> if it is off the result set     * @throws SQLException if (1) a database access error occurs,     *            (2) the result set type is <code>TYPE_FORWARD_ONLY</code>,     *            or (3) this rowset does not currently have a valid     *            connection, prepared statement, and result set     */    public boolean previous() throws SQLException {        checkState();         boolean b = rs.previous();        notifyCursorMoved();        return b;    }     /**     * Gives a hint as to the direction in which the rows in this     * <code>ResultSet</code> object will be processed.     * The initial value is determined by the     * <code>Statement</code> object     * that produced this rowset's <code>ResultSet</code> object.     * The fetch direction may be changed at any time.     *     * @throws SQLException if (1) a database access error occurs,     *            (2) the result set type is <code>TYPE_FORWARD_ONLY</code>     *            and the fetch direction is not <code>FETCH_FORWARD</code>,     *            or (3) this rowset does not currently have a valid     *            connection, prepared statement, and result set     * @see java.sql.Statement#setFetchDirection     */    public void setFetchDirection(int direction) throws SQLException {        checkState();         rs.setFetchDirection(direction);    }     /**     * Returns the fetch direction for this     * <code>ResultSet</code> object.     *     * @return the current fetch direction for this rowset's     *         <code>ResultSet</code> object     * @throws SQLException if a database access error occurs     *            or this rowset does not currently have a valid connection,     *            prepared statement, and result set     */    public int getFetchDirection() throws SQLException {        try {             checkState();        } catch(SQLException sqle) {             super.getFetchDirection();        }        return rs.getFetchDirection();    }     /**     * 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</code> 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</code> 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 (1) a database access error occurs, (2) the     *            condition <code>0 <= rows <= this.getMaxRows()</code> is not     *            satisfied, or (3) this rowset does not currently have a valid     *            connection, prepared statement, and result set     *     */    public void setFetchSize(int rows) throws SQLException {        checkState();         rs.setFetchSize(rows);    }     /**     *     * Returns the fetch size for this     * <code>ResultSet</code> object.     *     * @return the current fetch size for this rowset's <code>ResultSet</code> object     * @throws SQLException if a database access error occurs     *            or this rowset does not currently have a valid connection,     *            prepared statement, and result set     */    public int getType() throws SQLException {        try {             checkState();        } catch(SQLException sqle) {            return super.getType();        }         // If the ResultSet has not been created, then return the default type        // otherwise return the type from the ResultSet.        if(rs == null) {            return super.getType();        } else {           int rstype = rs.getType();            return rstype;        }      }     /**     * Returns the concurrency mode of this rowset's <code>ResultSet</code> object.     * The concurrency used is determined by the     * <code>Statement</code> object that created the result set.     *     * @return the concurrency type, either <code>CONCUR_READ_ONLY</code>     * or <code>CONCUR_UPDATABLE</code>     * @throws SQLException if (1) a database access error occurs     *            or (2) this rowset does not currently have a valid connection,     *            prepared statement, and result set     */    public int getConcurrency() throws SQLException {        try {             checkState();        } catch(SQLException sqle) {             super.getConcurrency();        }        return rs.getConcurrency();    }     //---------------------------------------------------------------------    // Updates    //---------------------------------------------------------------------     /**     * Indicates whether the current row has been updated.  The value returned     * depends on whether or not the result set can detect updates.     *     * @return <code>true</code> if the row has been visibly updated     * by the owner or another, and updates are detected     * @throws SQLException if a database access error occurs     *            or this rowset does not currently have a valid connection,     *            prepared statement, and result set     * @see java.sql.DatabaseMetaData#updatesAreDetected     */    public boolean rowUpdated() throws SQLException {        checkState();         return rs.rowUpdated();    }     /**     * Indicates whether the current row has had an insertion.     * The value returned depends on whether or not this     * <code>ResultSet</code> object can detect visible inserts.     *     * @return <code>true</code> if a row has had an insertion     * and insertions are detected; <code>false</code> otherwise     * @throws SQLException if a database access error occurs     *            or this rowset does not currently have a valid connection,     *            prepared statement, and result set     * @see java.sql.DatabaseMetaData#insertsAreDetected     *     */    public boolean rowInserted() throws SQLException {        checkState();         return rs.rowInserted();    }     /**     * Indicates whether a row has been deleted.  A deleted row may leave     * a visible "hole" in a result set.  This method can be used to     * detect holes in a result set.  The value returned depends on whether     * or not this rowset's <code>ResultSet</code> object can detect deletions.     *     * @return <code>true</code> if a row was deleted and deletions are detected;     * <code>false</code> otherwise     * @throws SQLException if a database access error occurs     *            or this rowset does not currently have a valid connection,     *            prepared statement, and result set     * @see java.sql.DatabaseMetaData#deletesAreDetected     */    public boolean rowDeleted() throws SQLException {        checkState();         return rs.rowDeleted();    }     /**     * Gives a nullable column a null value.     *     * The <code>updateXXX</code> methods are used to update column values in the     * current row or the insert row.  The <code>updateXXX</code> methods do not     * update the underlying database; instead the <code>updateRow</code>     * or <code>insertRow</code> methods are called to update the database.     *     * @param columnIndex the first column is 1, the second is 2, and so on     * @throws SQLException if a database access error occurs     *            or this rowset does not currently have a valid connection,     *            prepared statement, and result set     */    public void updateNull(int columnIndex) throws SQLException {        checkState();         // To check the type and concurrency of the ResultSet        // to verify whether updates are possible or not        checkTypeConcurrency();         rs.updateNull(columnIndex);    }     /**     * Updates the designated column with a <code>boolean</code> value.     * The <code>updateXXX</code> methods are used to update column values in the     * current row or the insert row.  The <code>updateXXX</code> methods do not     * update the underlying database; instead the <code>updateRow</code> or     * <code>insertRow</code> methods are called to update the database.     *     * @param columnIndex the first column is 1, the second is 2, and so on     * @param x the new column value     * @throws SQLException if a database access error occurs     *            or this rowset does not currently have a valid connection,     *            prepared statement, and result set     *     */    public void updateBoolean(int columnIndex, boolean x) throws SQLException {        checkState();         // To check the type and concurrency of the ResultSet        // to verify whether updates are possible or not        checkTypeConcurrency();         rs.updateBoolean(columnIndex, x);    }     /**     * Updates the designated column with a <code>byte</code> value.     * The <code>updateXXX</code> methods are used to update column values in the     * current row or the insert row.  The <code>updateXXX</code> methods do not     * update the underlying database; instead the <code>updateRow</code> or     * <code>insertRow</code> methods are called to update the database.     *     *     * @param columnIndex the first column is 1, the second is 2, and so on     * @param x the new column value     * @throws SQLException if a database access error occurs     *            or this rowset does not currently have a valid connection,     *            prepared statement, and result set     *     */    public void updateByte(int columnIndex, byte x) throws SQLException {        checkState();         // To check the type and concurrency of the ResultSet        // to verify whether updates are possible or not        checkTypeConcurrency();         rs.updateByte(columnIndex, x);    }     /**     * Updates the designated column with a <code>short</code> value.     * The <code>updateXXX</code> methods are used to update column values in the     * current row or the insert row.  The <code>updateXXX</code> methods do not     * update the underlying database; instead the <code>updateRow</code> or     * <code>insertRow</code> methods are called to update the database.     *     * @param columnIndex the first column is 1, the second is 2, and so on     * @param x the new column value     * @throws SQLException if a database access error occurs     *            or this rowset does not currently have a valid connection,     *            prepared statement, and result set     *     */    public void updateShort(int columnIndex, short x) throws SQLException {        checkState();         // To check the type and concurrency of the ResultSet        // to verify whether updates are possible or not        checkTypeConcurrency();         rs.updateShort(columnIndex, x);    }     /**     * Updates the designated column with an <code>int</code> value.     * The <code>updateXXX</code> methods are used to update column values in the     * current row or the insert row.  The <code>updateXXX</code> methods do not     * update the underlying database; instead the <code>updateRow</code> or     * <code>insertRow</code> methods are called to update the database.     *     * @param columnIndex the first column is 1, the second is 2, and so on     * @param x the new column value     * @throws SQLException if a database access error occurs     *            or this rowset does not currently have a valid connection,     *            prepared statement, and result set     */    public void updateInt(int columnIndex, int x) throws SQLException {        checkState();         // To check the type and concurrency of the ResultSet        // to verify whether updates are possible or not        checkTypeConcurrency();         rs.updateInt(columnIndex, x);    }     /**     * Updates the designated column with a <code>long</code> value.     * The <code>updateXXX</code> methods are used to update column values in the     * current row or the insert row.  The <code>updateXXX</code> methods do not     * update the underlying database; instead the <code>updateRow</code> or     * <code>insertRow</code> methods are called to update the database.     *     * @param columnIndex the first column is 1, the second is 2, and so on     * @param x the new column value     * @throws SQLException if a database access error occurs     *            or this rowset does not currently have a valid connection,     *            prepared statement, and result set     *     */    public void updateLong(int columnIndex, long x) throws SQLException {        checkState();         // To check the type and concurrency of the ResultSet        // to verify whether updates are possible or not        checkTypeConcurrency();         rs.updateLong(columnIndex, x);    }     /**     * Updates the designated column with a <code>float</code> value.     * The <code>updateXXX</code> methods are used to update column values in the     * current row or the insert row.  The <code>updateXXX</code> methods do not     * update the underlying database; instead the <code>updateRow</code> or     * <code>insertRow</code> methods are called to update the database.     *     * @param columnIndex the first column is 1, the second is 2, and so on     * @param x the new column value     * @throws SQLException if a database access error occurs     *            or this rowset does not currently have a valid connection,     *            prepared statement, and result set     *     */    public void updateFloat(int columnIndex, float x) throws SQLException {        checkState();         // To check the type and concurrency of the ResultSet        // to verify whether updates are possible or not        checkTypeConcurrency();         rs.updateFloat(columnIndex, x);    }     /**     * Updates the designated column with a <code>double</code> value.     * The <code>updateXXX</code> methods are used to update column values in the     * current row or the insert row.  The <code>updateXXX</code> methods do not     * update the underlying database; instead the <code>updateRow</code> or     * <code>insertRow</code> methods are called to update the database.     *     * @param columnIndex the first column is 1, the second is 2, and so on     * @param x the new column value     * @throws SQLException if a database access error occurs     *            or this rowset does not currently have a valid connection,     *            prepared statement, and result set     *     */    public void updateDouble(int columnIndex, double x) throws SQLException {        checkState();         // To check the type and concurrency of the ResultSet        // to verify whether updates are possible or not        checkTypeConcurrency();         rs.updateDouble(columnIndex, x);    }     /**     * Updates the designated column with a <code>java.math.BigDecimal</code>     * value.     * The <code>updateXXX</code> methods are used to update column values in the     * current row or the insert row.  The <code>updateXXX</code> methods do not     * update the underlying database; instead the <code>updateRow</code> or     * <code>insertRow</code> methods are called to update the database.     *     * @param columnIndex the first column is 1, the second is 2, and so on     * @param x the new column value     * @throws SQLException if a database access error occurs     *            or this rowset does not currently have a valid connection,     *            prepared statement, and result set     *     */    public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException {        checkState();         // To check the type and concurrency of the ResultSet        // to verify whether updates are possible or not        checkTypeConcurrency();         rs.updateBigDecimal(columnIndex, x);    }     /**     * Updates the designated column with a <code>String</code> value.     * The <code>updateXXX</code> methods are used to update column values in the     * current row or the insert row.  The <code>updateXXX</code> methods do not     * update the underlying database; instead the <code>updateRow</code> or     * <code>insertRow</code> methods are called to update the database.     *     * @param columnIndex the first column is 1, the second is 2, and so on     * @param x the new column value     * @throws SQLException if a database access error occurs     *            or this rowset does not currently have a valid connection,     *            prepared statement, and result set     *     */    public void updateString(int columnIndex, String x) throws SQLException {        checkState();         // To check the type and concurrency of the ResultSet        // to verify whether updates are possible or not        checkTypeConcurrency();         rs.updateString(columnIndex, x);    }     /**     * Updates the designated column with a <code>byte</code> array value.     * The <code>updateXXX</code> methods are used to update column values in the     * current row or the insert row.  The <code>updateXXX</code> methods do not     * update the underlying database; instead the <code>updateRow</code> or     * <code>insertRow</code> methods are called to update the database.     *     * @param columnIndex the first column is 1, the second is 2, and so on     * @param x the new column value     * @throws SQLException if a database access error occurs     *            or this rowset does not currently have a valid connection,     *            prepared statement, and result set     *     */    public void updateBytes(int columnIndex, byte x[]) throws SQLException {        checkState();         // To check the type and concurrency of the ResultSet        // to verify whether updates are possible or not        checkTypeConcurrency();         rs.updateBytes(columnIndex, x);    }     /**     * Updates the designated column with a <code>java.sql.Date</code> value.     * The <code>updateXXX</code> methods are used to update column values in the     * current row or the insert row.  The <code>updateXXX</code> methods do not     * update the underlying database; instead the <code>updateRow</code> or     * <code>insertRow</code> methods are called to update the database.     *     * @param columnIndex the first column is 1, the second is 2, and so on     * @param x the new column value     * @throws SQLException if a database access error occurs     *            or this rowset does not currently have a valid connection,     *            prepared statement, and result set     *     */    public void updateDate(int columnIndex, java.sql.Date x) throws SQLException {        checkState();         // To check the type and concurrency of the ResultSet        // to verify whether updates are possible or not        checkTypeConcurrency();         rs.updateDate(columnIndex, x);    }      /**     * Updates the designated column with a <code>java.sql.Time</code> value.     * The <code>updateXXX</code> methods are used to update column values in the     * current row or the insert row.  The <code>updateXXX</code> methods do not     * update the underlying database; instead the <code>updateRow</code> or     * <code>insertRow</code> methods are called to update the database.     *     * @param columnIndex the first column is 1, the second is 2, and so on

Lines 2001–2500 of 7047. Previous lines Load more