resultset_2_0.java

数据仓库工具

     * JDBC 2.0
     *
     * The rows in a result set will be processed in a forward direction;
     * first-to-last.
     */
   int FETCH_FORWARD = 1000;

   /**
     * JDBC 2.0
     *
     * The rows in a result set will be processed in a reverse direction;
     * last-to-first.
     */
   int FETCH_REVERSE = 1001;

   /**
     * JDBC 2.0
     * 
     * The order in which rows in a result set will be processed is unknown.
     */
   int FETCH_UNKNOWN = 1002;

   /**
     * JDBC 2.0
     *
     * Gives a hint as to the direction in which the rows in this result set
     * will be processed.  The initial value is determined by the statement
     * that produced the result set.  The fetch direction may be changed
     * at any time.
     *
     * @exception SQLException if a database access error occurs or
     * the result set type is TYPE_FORWARD_ONLY and the fetch direction is not 
     * FETCH_FORWARD.
     */
   public void setFetchDirection(int direction) throws SQLException
   {
      NotImplemented();
   }


   /**
     * JDBC 2.0
     *
     * Returns the fetch direction for this result set.
     *
     * @return the current fetch direction for this result set
     * @exception SQLException if a database access error occurs
     */
   public int getFetchDirection() throws SQLException
   {
      NotImplemented();
      return 0;
   }


   /**
     * JDBC 2.0
     *
     * 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 result
     * set.  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 statement 
     * 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 0 <= rows <= this.getMaxRows() is not satisfied.
     */
   public void setFetchSize(int rows) throws SQLException
   {
      NotImplemented();
   }


   /**
     * JDBC 2.0
     *
     * Returns the fetch size for this result set.
     *
     * @return the current fetch size for this result set
     * @exception SQLException if a database access error occurs
     */
   public int getFetchSize() throws SQLException
   {
      NotImplemented();
      return 0;
   }


   /**
     * JDBC 2.0
     * The type for a <code>ResultSet</code> object whose cursor may
     * move only forward.
     */
   int TYPE_FORWARD_ONLY = 1003;

   /**
     * JDBC 2.0
     * The type for a <code>ResultSet</code> object that is scrollable
     * but generally not sensitive to changes made by others.
     * 
     */
   int TYPE_SCROLL_INSENSITIVE = 1004;
   
   /**
     * JDBC 2.0
     * The type for a <code>ResultSet</code> object that is scrollable
     * and generally sensitive to changes made by others.
     */
   int TYPE_SCROLL_SENSITIVE = 1005;

   /**
     * JDBC 2.0
     *
     * Returns the type of this result set.  The type is determined by
     * the statement that created the result set.
     *
     * @return TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE, or
     * TYPE_SCROLL_SENSITIVE
     * @exception SQLException if a database access error occurs
     */
   public int getType() throws SQLException
   {
      NotImplemented();
      return 0;
   }


   /**
     * JDBC 2.0
     * The concurrency mode for a <code>ResultSet</code> object
     * that may NOT be updated.
     *  
     */
   int CONCUR_READ_ONLY = 1007;

   /**
     * JDBC 2.0
     * The concurrency mode for a <code>ResultSet</code> object
     * that may be updated.
     * 
     */
   int CONCUR_UPDATABLE = 1008;
   
   /**
    * JDBC 2.0
    *
    * Returns the concurrency mode of this result set.  The concurrency
    * used is determined by the statement that created the result set.
    *
    * @return the concurrency type, CONCUR_READ_ONLY or CONCUR_UPDATABLE
    * @exception SQLException if a database access error occurs
    */
   public int getConcurrency() throws SQLException
   {
      NotImplemented();
      return 0;
   }
   
   
   //---------------------------------------------------------------------
   // Updates
   //---------------------------------------------------------------------
   
   /**
    * JDBC 2.0
    *
    * Indicates whether 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
    * 
    * @see DatabaseMetaData#updatesAreDetected
    */
   public boolean rowUpdated() throws SQLException
   {
      NotImplemented();
      return false;
   }
   
   
   /**
    * JDBC 2.0
    *
    * Indicates whether the current row has had an insertion.  The value returned 
    * depends on whether or not the result set can detect visible inserts.
    *
    * @return true if a row has had an insertion and insertions are detected
    * @exception SQLException if a database access error occurs
    * 
    * @see DatabaseMetaData#insertsAreDetected
    */
   public boolean rowInserted() throws SQLException
   {
      NotImplemented();
      return false;
   }

   
   /**
    * JDBC 2.0
    *
    * 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 the result set can detect deletions.
    *
    * @return true if a row was deleted and deletions are detected
    * @exception SQLException if a database access error occurs
    * 
    * @see DatabaseMetaData#deletesAreDetected
    */
   public boolean rowDeleted() throws SQLException
   {
      NotImplemented();
      return false;
   }


   /**
    * JDBC 2.0
    * 
    * Give 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, ...
    * @exception SQLException if a database access error occurs
    */
   public void updateNull(int columnIndex) throws SQLException
   {
      NotImplemented();
   }


   /**
    * JDBC 2.0
    * 
    * Updates a column with a boolean 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, ...
    * @param x the new column value
    * @exception SQLException if a database access error occurs
    */
   public void updateBoolean(int columnIndex, boolean x) throws SQLException
   {
      NotImplemented();
   }


   /**
    * JDBC 2.0
    *   
    * Updates a column with a byte 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, ...
    * @param x the new column value
    * @exception SQLException if a database access error occurs
    */
   public void updateByte(int columnIndex, byte x) throws SQLException
   {
      NotImplemented();
   }


   /**
    * JDBC 2.0
    *   
    * Updates a column with a short 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, ...
    * @param x the new column value
    * @exception SQLException if a database access error occurs
    */
   public void updateShort(int columnIndex, short x) throws SQLException
   {
      NotImplemented();
   }


   /**
    * JDBC 2.0
    *   
    * Updates a column with an integer 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, ...
    * @param x the new column value
    * @exception SQLException if a database access error occurs
    */
   public void updateInt(int columnIndex, int x) throws SQLException
   {
      NotImplemented();
   }


   /**
    * JDBC 2.0
    *   
    * Updates a column with a long 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, ...
    * @param x the new column value
    * @exception SQLException if a database access error occurs
    */
   public void updateLong(int columnIndex, long x) throws SQLException
   {
      NotImplemented();
   }


   /**
    * JDBC 2.0
    *  
    * Updates a column with a float 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, ...
    * @param x the new column value
    * @exception SQLException if a database access error occurs
    */
   public void updateFloat(int columnIndex, float x) throws SQLException
   {
      NotImplemented();
   }


   /**
    * JDBC 2.0
    *  
    * Updates a column with a Double 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, ...