xmlresultset.java

数据仓库工具

 */
public boolean isBeforeFirst() throws SQLException {
  throw new UnsupportedOperationException(
      "ResultSet.isBeforeFirst() unsupported");
}

/**
 * Retrieves whether the cursor is after the last row in
 * this <code>ResultSet</code> object.
 *
 * @return <code>true</code> if the cursor is after the last row;
 * <code>false</code> if the cursor is at any other position or the
 * result set contains no rows
 * @exception SQLException if a database access error occurs
 */
public boolean isAfterLast() throws SQLException {
  throw new UnsupportedOperationException(
      "ResultSet.isAfterLast() unsupported");
}

/**
 * Retrieves whether the cursor is on the first row of
 * this <code>ResultSet</code> object.
 *
 * @return <code>true</code> if the cursor is on the first row;
 * <code>false</code> otherwise
 * @exception SQLException if a database access error occurs
 */
public boolean isFirst() throws SQLException {
  throw new UnsupportedOperationException(
      "ResultSet.isFirst() unsupported");
}

/**
 * Retrieves whether the cursor is on the last row of
 * this <code>ResultSet</code> object.
 * Note: Calling the method <code>isLast</code> 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.
 *
 * @return <code>true</code> if the cursor is on the last row;
 * <code>false</code> otherwise
 * @exception SQLException if a database access error occurs
 */
public boolean isLast() throws SQLException {
  throw new UnsupportedOperationException(
      "ResultSet.isLast() unsupported");
}

/**
 * Moves the cursor to the front of
 * this <code>ResultSet</code> object, just before the
 * first row. This method has no effect if the result set contains no rows.
 *
 * @exception SQLException if a database access error
 * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
 */
public void beforeFirst() throws SQLException {
  throw new UnsupportedOperationException(
      "ResultSet.beforeFirst() unsupported");
}

/**
 * Moves the cursor to the end of
 * this <code>ResultSet</code> object, just after the
 * last row. This method has no effect if the result set contains no rows.
 * @exception SQLException if a database access error
 * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
 */
public void afterLast() throws SQLException {
  throw new UnsupportedOperationException(
      "ResultSet.afterLast() unsupported");
}

/**
 * Moves the cursor to the first row in
 * this <code>ResultSet</code> object.
 *
 * @return <code>true</code> if the cursor is on a valid row;
 * <code>false</code> if there are no rows in the result set
 * @exception SQLException if a database access error
 * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
 */
public boolean first() throws SQLException {
  throw new UnsupportedOperationException(
      "ResultSet.first() unsupported");
}

/**
 * Moves the cursor to the last row in
 * this <code>ResultSet</code> object.
 *
 * @return <code>true</code> if the cursor is on a valid row;
 * <code>false</code> if there are no rows in the result set
 * @exception SQLException if a database access error
 * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
 */
public boolean last() throws SQLException {
  throw new UnsupportedOperationException("ResultSet.last() unsupported");
}

/**
 * Retrieves the current row number.  The first row is number 1, the
 * second number 2, and so on.
 *
 * @return the current row number; <code>0</code> if there is no current row
 * @exception SQLException if a database access error occurs
 */
public int getRow() throws SQLException {
  throw new UnsupportedOperationException(
      "ResultSet.getRow() unsupported");
}

/**
 * Moves the cursor to the given row number in
 * this <code>ResultSet</code> object.
 *
 * <p>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.
 *
 * <p>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)</code> positions the
 * cursor on the last row; calling the method <code>absolute(-2)</code>
 * moves the cursor to the next-to-last row, and so on.
 *
 * <p>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.
 *
 * <p><B>Note:</B> Calling <code>absolute(1)</code> is the same
 * as calling <code>first()</code>. Calling <code>absolute(-1)</code>
 * is the same as calling <code>last()</code>.
 *
 * @param row the number of the row to which the cursor should move.
 *        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</code> if the cursor is on the result set;
 * <code>false</code> otherwise
 * @exception SQLException if a database access error
 * occurs, or the result set type is <code>TYPE_FORWARD_ONLY</code>
 */
public boolean absolute(int row) throws SQLException {
  throw new UnsupportedOperationException(
      "ResultSet.absolute() unsupported");
}

/**
 * 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)</code> is valid, but does
 * not change the cursor position.
 *
 * <p>Note: Calling the method <code>relative(1)</code>
 * is identical to calling the method <code>next()</code> and
 * calling the method <code>relative(-1)</code> is identical
 * to calling the method <code>previous()</code>.
 *
 * @param rows an <code>int</code> 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</code> if the cursor is on a row;
 *         <code>false</code> otherwise
 * @exception SQLException if a database access error occurs,
 *            there is no current row, or the result set type is
 *            <code>TYPE_FORWARD_ONLY</code>
 */
public boolean relative(int rows) throws SQLException {
  throw new UnsupportedOperationException(
      "ResultSet.relative() unsupported");
}

/**
 * Moves the cursor to the previous row in this
 * <code>ResultSet</code> object.
 *
 * @return <code>true</code> if the cursor is on a valid row;
 * <code>false</code> if it is off the result set
 * @exception SQLException if a database access error
 * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
 */
public boolean previous() throws SQLException {
  throw new UnsupportedOperationException(
      "ResultSet.previous() unsupported");
}

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

/**
 * 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
 * <code>ResultSet</code> object. The fetch direction may be changed at
 * any time.
 *
 * @param direction an <code>int</code> specifying the suggested
 *        fetch direction; one of <code>ResultSet.FETCH_FORWARD</code>,
 *        <code>ResultSet.FETCH_REVERSE</code>, or
 *        <code>ResultSet.FETCH_UNKNOWN</code>
 * @exception SQLException if a database access error occurs or
 *            the result set type is <code>TYPE_FORWARD_ONLY</code>
 *            and the fetch direction is not <code>FETCH_FORWARD</code>
 */
public void setFetchDirection(int direction) throws SQLException {
  throw new UnsupportedOperationException(
      "ResultSet.setFetchDirection(int) unsupported");
}

/**
 * Retrieves the fetch direction for this
 * <code>ResultSet</code> object.
 *
 * @return the current fetch direction for this <code>ResultSet</code>
 *         object
 * @exception SQLException if a database access error occurs
 * @see #setFetchDirection
 */
public int getFetchDirection() throws SQLException {
  throw new UnsupportedOperationException(
      "ResultSet.getFetchDirection() unsupported");
}

/**
 * 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
 * @exception SQLException if a database access error occurs or the
 * condition <code>0 <= rows <= this.getMaxRows()</code> is not satisfied
 */
public void setFetchSize(int rows) throws SQLException {
  throw new UnsupportedOperationException(
      "ResultSet.setFetchSize(int) unsupported");
}

/**
 * Retrieves the fetch size for this
 * <code>ResultSet</code> object.
 *
 * @return the current fetch size for this <code>ResultSet</code> object
 * @exception SQLException if a database access error occurs
 * @see #setFetchSize
 */
public int getFetchSize() throws SQLException {
  throw new UnsupportedOperationException(
      "ResultSet.getFetchSize() unsupported");
}

/**
 * Retrieves the type of this <code>ResultSet</code> object.
 * The type is determined by the <code>Statement</code> object
 * that created the result set.
 *
 * @return <code>ResultSet.TYPE_FORWARD_ONLY</code>,
 *         <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>,
 *         or <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
 * @exception SQLException if a database access error occurs
 */
public int getType() throws SQLException {
  throw new UnsupportedOperationException(
      "ResultSet.getType() unsupported");
}

/**
 * Retrieves the concurrency mode of this <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>ResultSet.CONCUR_READ_ONLY</code>
 *         or <code>ResultSet.CONCUR_UPDATABLE</code>
 * @exception SQLException if a database access error occurs
 */
public int getConcurrency() throws SQLException {
  return CONCUR_READ_ONLY;
}

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

/**
 * Retrieves 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 both (1) the row has been visibly updated
 *         by the owner or another and (2) updates are detected
 * @exception SQLException if a database access error occurs
 * @see DatabaseMetaData#updatesAreDetected
 */
public boolean rowUpdated() throws SQLException {
  throw new UnsupportedOperationException(
      "ResultSet.rowUpdated() unsupported");
}

/**
 * Retrieves 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
 * @exception SQLException if a database access error occurs
 *
 * @see DatabaseMetaData#insertsAreDetected
 */
public boolean rowInserted() throws SQLException {
  throw new UnsupportedOperationException(
      "ResultSet.rowInserted() unsupported");
}

/**
 * Retrieves 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 <code>ResultSet</code> object can detect deletions.
 *
 * @return <code>true</code> if a row was deleted and deletions are