* </p>     *      * <p>     * Note: Calling relative(1) is different than calling next() since is     * makes sense to call next() when there is no current row, for example,     * when the cursor is positioned before the first row or after the last     * row of the result set.     * </p>     *     * @param rows DOCUMENT ME!     *     * @return true if on a row, false otherwise.     *     * @exception SQLException if a database-access error occurs, or there is     *            no current row, or result set type is TYPE_FORWARD_ONLY.     */    public synchronized boolean relative(int rows) throws SQLException {        return super.relative(rows);    }    /**     * JDBC 2.0 Determine if this 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 the result set can detect deletions.     *     * @return true if deleted and deletes are detected     *     * @exception SQLException if a database-access error occurs     * @throws NotImplemented DOCUMENT ME!     *     * @see DatabaseMetaData#deletesAreDetected     */    public synchronized boolean rowDeleted() throws SQLException {        throw new NotImplemented();    }    /**     * JDBC 2.0 Determine if the current row has been inserted.  The value     * returned  depends on whether or not the result set can detect visible     * inserts.     *     * @return true if inserted and inserts are detected     *     * @exception SQLException if a database-access error occurs     * @throws NotImplemented DOCUMENT ME!     *     * @see DatabaseMetaData#insertsAreDetected     */    public synchronized boolean rowInserted() throws SQLException {        throw new NotImplemented();    }    //---------------------------------------------------------------------    // Updates    //---------------------------------------------------------------------    /**     * JDBC 2.0 Determine if the current row has been updated.  The value     * returned  depends on whether or not the result set can detect updates.     *     * @return true if the row has been visibly updated by the owner or     *         another, and updates are detected     *     * @exception SQLException if a database-access error occurs     * @throws NotImplemented DOCUMENT ME!     *     * @see DatabaseMetaData#updatesAreDetected     */    public synchronized boolean rowUpdated() throws SQLException {        throw new NotImplemented();    }    /**     * JDBC 2.0  Update a column with an ascii stream value. The updateXXX()     * methods are used to update column values in the current row, or the     * insert row.  The updateXXX() methods do not  update the underlying     * database, instead the updateRow() or insertRow() methods are called to     * update the database.     *     * @param columnIndex the first column is 1, the second is 2, ...     * @param x the new column value     * @param length the length of the stream     *     * @exception SQLException if a database-access error occurs     */    public synchronized void updateAsciiStream(int columnIndex,        java.io.InputStream x, int length) throws SQLException {        if (!onInsertRow) {            if (!doingUpdates) {                doingUpdates = true;                syncUpdate();            }            updater.setAsciiStream(columnIndex, x, length);        } else {            inserter.setAsciiStream(columnIndex, x, length);            this.thisRow[columnIndex - 1] = STREAM_DATA_MARKER;        }    }    /**     * JDBC 2.0  Update a column with an ascii stream value. The updateXXX()     * methods are used to update column values in the current row, or the     * insert row.  The updateXXX() methods do not  update the underlying     * database, instead the updateRow() or insertRow() methods are called to     * update the database.     *     * @param columnName the name of the column     * @param x the new column value     * @param length of the stream     *     * @exception SQLException if a database-access error occurs     */    public synchronized void updateAsciiStream(String columnName,        java.io.InputStream x, int length) throws SQLException {        updateAsciiStream(findColumn(columnName), x, length);    }    /**     * JDBC 2.0  Update a column with a BigDecimal value. The updateXXX()     * methods are used to update column values in the current row, or the     * insert row.  The updateXXX() methods do not  update the underlying     * database, instead the updateRow() or insertRow() methods are called to     * update the database.     *     * @param columnIndex the first column is 1, the second is 2, ...     * @param x the new column value     *     * @exception SQLException if a database-access error occurs     */    public synchronized void updateBigDecimal(int columnIndex, BigDecimal x)        throws SQLException {        if (!onInsertRow) {            if (!doingUpdates) {                doingUpdates = true;                syncUpdate();            }            updater.setBigDecimal(columnIndex, x);        } else {            inserter.setBigDecimal(columnIndex, x);            if (x == null) {                this.thisRow[columnIndex - 1] = null;            } else {                this.thisRow[columnIndex - 1] = x.toString().getBytes();            }        }    }    /**     * JDBC 2.0  Update a column with a BigDecimal value. The updateXXX()     * methods are used to update column values in the current row, or the     * insert row.  The updateXXX() methods do not  update the underlying     * database, instead the updateRow() or insertRow() methods are called to     * update the database.     *     * @param columnName the name of the column     * @param x the new column value     *     * @exception SQLException if a database-access error occurs     */    public synchronized void updateBigDecimal(String columnName, BigDecimal x)        throws SQLException {        updateBigDecimal(findColumn(columnName), x);    }    /**     * JDBC 2.0  Update a column with a binary stream value. The updateXXX()     * methods are used to update column values in the current row, or the     * insert row.  The updateXXX() methods do not  update the underlying     * database, instead the updateRow() or insertRow() methods are called to     * update the database.     *     * @param columnIndex the first column is 1, the second is 2, ...     * @param x the new column value     * @param length the length of the stream     *     * @exception SQLException if a database-access error occurs     */    public synchronized void updateBinaryStream(int columnIndex,        java.io.InputStream x, int length) throws SQLException {        if (!onInsertRow) {            if (!doingUpdates) {                doingUpdates = true;                syncUpdate();            }            updater.setBinaryStream(columnIndex, x, length);        } else {            inserter.setBinaryStream(columnIndex, x, length);            if (x == null) {                this.thisRow[columnIndex - 1] = null;            } else {                this.thisRow[columnIndex - 1] = STREAM_DATA_MARKER;            }        }    }    /**     * JDBC 2.0  Update a column with a binary stream value. The updateXXX()     * methods are used to update column values in the current row, or the     * insert row.  The updateXXX() methods do not  update the underlying     * database, instead the updateRow() or insertRow() methods are called to     * update the database.     *     * @param columnName the name of the column     * @param x the new column value     * @param length of the stream     *     * @exception SQLException if a database-access error occurs     */    public synchronized void updateBinaryStream(String columnName,        java.io.InputStream x, int length) throws SQLException {        updateBinaryStream(findColumn(columnName), x, length);    }    /**     * @see ResultSet#updateBlob(int, Blob)     */    public synchronized void updateBlob(int columnIndex, java.sql.Blob blob)        throws SQLException {        if (!onInsertRow) {            if (!doingUpdates) {                doingUpdates = true;                syncUpdate();            }            updater.setBlob(columnIndex, blob);        } else {            inserter.setBlob(columnIndex, blob);            if (blob == null) {                this.thisRow[columnIndex - 1] = null;            } else {                this.thisRow[columnIndex - 1] = STREAM_DATA_MARKER;            }        }    }    /**     * @see ResultSet#updateBlob(String, Blob)     */    public void updateBlob(String columnName, java.sql.Blob blob)        throws SQLException {        updateBlob(findColumn(columnName), blob);    }    /**     * JDBC 2.0  Update a column with a boolean value. The updateXXX() methods     * are used to update column values in the current row, or the insert row.     * The updateXXX() methods do not  update the underlying database, instead     * the updateRow() or insertRow() methods are called to update the     * database.     *     * @param columnIndex the first column is 1, the second is 2, ...     * @param x the new column value     *     * @exception SQLException if a database-access error occurs     */    public synchronized void updateBoolean(int columnIndex, boolean x)        throws SQLException {        if (!onInsertRow) {            if (!doingUpdates) {                doingUpdates = true;                syncUpdate();            }            updater.setBoolean(columnIndex, x);        } else {            inserter.setBoolean(columnIndex, x);            this.thisRow[columnIndex - 1] = inserter.getBytes(1);        }    }    /**     * JDBC 2.0  Update a column with a boolean value. The updateXXX() methods     * are used to update column values in the current row, or the insert row.     * The updateXXX() methods do not  update the underlying database, instead     * the updateRow() or insertRow() methods are called to update the     * database.     *     * @param columnName the name of the column     * @param x the new column value     *     * @exception SQLException if a database-access error occurs     */    public synchronized void updateBoolean(String columnName, boolean x)        throws SQLException {        updateBoolean(findColumn(columnName), x);    }    /**     * JDBC 2.0  Update a column with a byte value. The updateXXX() methods are     * used to update column values in the current row, or the insert row. The     * updateXXX() methods do not  update the underlying database, instead the     * updateRow() or insertRow() methods are called to update the database.     *     * @param columnIndex the first column is 1, the second is 2, ...     * @param x the new column value     *     * @exception SQLException if a database-access error occurs     */    public synchronized void updateByte(int columnIndex, byte x)        throws SQLException {        if (!onInsertRow) {            if (!doingUpdates) {                doingUpdates = true;                syncUpdate();            }            updater.setByte(columnIndex, x);        } else {            inserter.setByte(columnIndex, x);            this.thisRow[columnIndex - 1] = inserter.getBytes(columnIndex - 1);        }    }    /**     * JDBC 2.0  Update a column with a byte value. The updateXXX() methods are     * used to update column values in the current row, or the insert row. The     * updateXXX() methods do not  update the underlying database, instead the     * updateRow() or insertRow() methods are called to update the database.     *     * @param columnName the name of the column     * @param x the new column value     *     * @exception SQLException if a database-access error occurs     */    public synchronized void updateByte(String columnName, byte x)        throws SQLException {        updateByte(findColumn(columnName), x);    }    /**     * JDBC 2.0  Update a column with a byte array value. The updateXXX()     * methods are used to update column values in the current row, or the     * insert row.  The updateXXX() methods do not  update the underlying     * database, instead the updateRow() or insertRow() methods are called to     * update the database.     *     * @param columnIndex the first column is 1, the second is 2, ...     * @param x the new column value     *     * @exception SQLException if a database-access error occurs     */    public synchronized void updateBytes(int columnIndex, byte[] x)        throws SQLException {        if (!onInsertRow) {            if (!doingUpdates) {                doingUpdates = true;                syncUpdate();            }            updater.setBytes(columnIndex, x);        } else {            inserter.setBytes(columnIndex, x);            this.thisRow[columnIndex - 1] = x;        }    }    /**     * JDBC 2.0  Update a column with a byte array value. The updateXXX()     * methods are used to update column values in the current row, or the     * insert row.  The updateXXX() methods do not  update the underlying     * database, instead the updateRow() or insertRow() methods are called to