jdbcstatement.java

一个可以在applet窗体上持行sql语句并显示返回结果的程序

/*
 * jdbcStatement.java
 */

package org.hsql;
import java.sql.*;

/**
 * <P>The object used for executing a static SQL statement
 * and obtaining the results produced by it. 
 *
 * <P>Only one ResultSet per Statement can be open at any point in
 * time. Therefore, if the reading of one ResultSet is interleaved
 * with the reading of another, each must have been generated by
 * different Statements. All statement <code>execute</code> methods implicitly
 * close a statment's current ResultSet if an open one exists.
 *
 * @see jdbcConnection#createStatement
 * @see jdbcResultSet
 */

public class jdbcStatement implements Statement {
  private jdbcConnection cConnection;
  private jdbcResultSet rSet;
  private boolean bEscapeProcessing;
  private int iMaxRows;

  /**
   * Executes a SQL statement that returns a single ResultSet.
   *
   * @param sql typically this is a static SQL SELECT statement
   * @return a ResultSet that contains the data produced by the
   * query; never null
   * @exception SQLException if a database access error occurs
   */
  public ResultSet executeQuery(String sql) throws SQLException {
    fetchResult(sql);
    return rSet;
  }
  /**
   * Executes an SQL INSERT, UPDATE or DELETE statement. In addition,
   * SQL statements that return nothing, such as SQL DDL statements,
   * can be executed.
   *
   * @param sql a SQL INSERT, UPDATE or DELETE statement or a SQL
   * statement that returns nothing
   * @return either the row count for INSERT, UPDATE or DELETE or 0
   * for SQL statements that return nothing
   * @exception SQLException if a database access error occurs
   */
  public int executeUpdate(String sql) throws SQLException {
    fetchResult(sql);
    if(rSet==null) {
      return -1;
    }
    return rSet.getUpdateCount();
  }
  /**
	 * Releases this <code>Statement</code> object's database
	 * and JDBC resources immediately instead of waiting for
	 * this to happen when it is automatically closed.
   * It is generally good practice to release resources as soon as
	 * you are finished with them to avoid tying up database
	 * resources.
   * <P><B>Note:</B> A Statement is automatically closed when it is
   * garbage collected. When a Statement is closed, its current
   * ResultSet, if one exists, is also closed.
   */
  public void close() {
    if(Trace.TRACE) Trace.trace();
    closeOldResult();
    rSet=null;
  }
  /**
   * Returns the maximum number of bytes allowed for any column value.
	 * This limit is the maximum number of bytes that can be
	 * returned for any column value.
	 * The limit applies only to BINARY,
   * VARBINARY, LONGVARBINARY, CHAR, VARCHAR, and LONGVARCHAR
   * columns.  If the limit is exceeded, the excess data is silently
   * discarded.
   * <P><font color="#009900">
   * In Hypersonic SQL, field sizes are always unlimited.
   * </font><P>
   * @return the current max column size limit; zero means unlimited
   */
  public int getMaxFieldSize() {
    if(Trace.TRACE) Trace.trace();
    // todo
    return 0;
  }
  /**
	 * Sets the limit for the maximum number of bytes in a column to
	 * the given number of bytes.  This is the maximum number of bytes
	 * that can be returned for any column value.  This limit applies
	 * only to BINARY, VARBINARY, LONGVARBINARY, CHAR, VARCHAR, and
   * LONGVARCHAR fields.  If the limit is exceeded, the excess data
   * is silently discarded. For maximum portability, use values
   * greater than 256.
   * <P><font color="#009900">
   * In Hypersonic SQL, field sizes are always unlimited.
   * </font><P>
   * @param max the new max column size limit; zero means unlimited
   */
  public void setMaxFieldSize(int max) {
    if(Trace.TRACE) Trace.trace();
    // todo
  }
  /**
   * Retrieves the maximum number of rows that a
   * ResultSet can contain.  If the limit is exceeded, the excess
   * rows are silently dropped.
   *
   * @return the current max row limit; zero means unlimited
   */
  public int getMaxRows() {
    if(Trace.TRACE) Trace.trace();
    return iMaxRows;
  }
  /**
   * Sets the limit for the maximum number of rows that any
   * ResultSet can contain to the given number.
	 * If the limit is exceeded, the excess
   * rows are silently dropped.
   *
   * @param max the new max rows limit; zero means unlimited
   */
  public void setMaxRows(int max) {
    if(Trace.TRACE) Trace.trace();
    iMaxRows=max;
  }
  /**
	 * Sets escape processing on or off.
   * If escape scanning is on (the default), the driver will do
   * escape substitution before sending the SQL to the database.
   *
   * Note: Since prepared statements have usually been parsed prior
   * to making this call, disabling escape processing for prepared
   * statements will have no effect.
   *
   * @param enable true to enable; false to disable
   */
  public void setEscapeProcessing(boolean enable) {
    if(Trace.TRACE) Trace.trace();
    bEscapeProcessing=enable;
  }
  /**
   * Retrieves the number of seconds the driver will
   * wait for a Statement to execute. If the limit is exceeded, a
   * SQLException is thrown.
   * <P><font color="#009900">
   * Hypersonic SQL currently does not support this feature.
   * Queries that take 1 second are very seldom.
   * </font><P>
   * @return the current query timeout limit in seconds; zero means unlimited
   */
  public int getQueryTimeout() {
    if(Trace.TRACE) Trace.trace();
    // todo
    return 0;
  }
  /**
   * Sets the number of seconds the driver will
   * wait for a Statement to execute to the given number of seconds.
	 * If the limit is exceeded, a SQLException is thrown.
   * <P><font color="#009900">
   * Hypersonic SQL currently does not support this feature.
   * Queries that take 1 second are very seldom.
   * </font><P>
   * @param seconds the new query timeout limit in seconds; zero means
   * unlimited
   */
  public void setQueryTimeout(int seconds) {
    if(Trace.TRACE) Trace.trace();
    // todo
  }
  /**
	 * Cancels this <code>Statement</code> object if both the DBMS and
	 * driver support aborting an SQL statement.
   * This method can be used by one thread to cancel a statement that
   * is being executed by another thread.
   * <P><font color="#009900">
   * Hypersonic SQL currently does not support this feature.
   * </font><P>
   */
  public void cancel() {
    if(Trace.TRACE) Trace.trace();
  }
  /**
   * Retrieves the first warning reported by calls on this Statement.
   * Subsequent Statement warnings will be chained to this
   * SQLWarning.
   *
   * <p>The warning chain is automatically cleared each time
   * a statement is (re)executed.
   *
   * <P><B>Note:</B> If you are processing a ResultSet, any
   * warnings associated with ResultSet reads will be chained on the
   * ResultSet object.
   * <P><font color="#009900">
   * Hypersonic SQL never produces warnings and returns always null.
   * </font><P>
   * @return the first SQLWarning or null
   */
  public SQLWarning getWarnings() {
    if(Trace.TRACE) Trace.trace();
    return null;
  }
  /**
	 * Clears all the warnings reported on this <code>Statement</code>
	 * object. After a call to this method,
	 * the method <code>getWarnings</code> will return
	 * null until a new warning is reported for this Statement.
   */
  public void clearWarnings() {
    if(Trace.TRACE) Trace.trace();
  }
  /**
   * Defines the SQL cursor name that will be used by
   * subsequent Statement <code>execute</code> methods. This name can then be
   * used in SQL positioned update/delete statements to identify the
   * current row in the ResultSet generated by this statement.  If
   * the database doesn't support positioned update/delete, this
   * method is a noop.  To insure that a cursor has the proper isolation
   * level to support updates, the cursor's SELECT statement should be
   * of the form 'select for update ...'. If the 'for update' phrase is
   * omitted, positioned updates may fail.
   * <P><font color="#009900">
   * Hypersonic SQL currently does not support this feature.
   * </font>
   * <P><B>Note:</B> By definition, positioned update/delete
   * execution must be done by a different Statement than the one
   * which generated the ResultSet being used for positioning. Also,
   * cursor names must be unique within a connection.
   *
   * @param name the new cursor name, which must be unique within
	 *             a connection
   */
  public void setCursorName(String name) {
    if(Trace.TRACE) Trace.trace();
  }
  /**
   * Executes a SQL statement that may return multiple results.
   * Under some (uncommon) situations a single SQL statement may return
   * multiple result sets and/or update counts.  Normally you can ignore
   * this unless you are (1) executing a stored procedure that you know may
   * return multiple results or (2) you are dynamically executing an
   * unknown SQL string.  The  methods <code>execute</code>,
	 * <code>getMoreResults</code>, <code>getResultSet</code>,
   * and <code>getUpdateCount</code> let you navigate through multiple results.
   *
   * The <code>execute</code> method executes a SQL statement and indicates the
   * form of the first result.  You can then use getResultSet or
   * getUpdateCount to retrieve the result, and getMoreResults to
   * move to any subsequent result(s).
   *
   * @param sql any SQL statement
   * @return true if the next result is a ResultSet; false if it is
   * an update count or there are no more results
   * @exception SQLException if a database access error occurs