Package | Class | Tree | Deprecated
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.hsqldb
Class jdbcStatement

    java.lang.Object
      |
      +--org.hsqldb.jdbcStatement

Direct Known Subclasses:
  jdbcPreparedStatement

public class jdbcStatement
extends java.lang.Object
implements java.sql.Statement

The object used for executing a static SQL statement and obtaining the results produced by it.

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 `execute` methods implicitly close a statment's current ResultSet if an open one exists.

See Also:
  `jdbcConnection.createStatement()`, `jdbcResultSet`

Constructor Summary
`(package private)` | `jdbcStatement(jdbcConnection c)` Constructor declaration

Method Summary
`void` | `addBatch(java.lang.String sql)` JDBC 2.0 Adds a SQL command to the current batch of commmands for the statement.
`void` | `cancel()` Cancels this `Statement` object if both the DBMS and driver support aborting an SQL statement.
`void` | `clearBatch()` JDBC 2.0 Makes the set of commands in the current batch empty.
`void` | `clearWarnings()` Clears all the warnings reported on this `Statement` object.
`void` | `close()` Releases this `Statement` object's database and JDBC resources immediately instead of waiting for this to happen when it is automatically closed.
`boolean` | `execute(java.lang.String sql)` Executes a SQL statement that may return multiple results.
`int[]` | `executeBatch()` JDBC 2.0 Submits a batch of commands to the database for execution.
`java.sql.ResultSet` | `executeQuery(java.lang.String sql)` Executes a SQL statement that returns a single ResultSet.
`int` | `executeUpdate(java.lang.String sql)` Executes an SQL INSERT, UPDATE or DELETE statement.
`java.sql.Connection` | `getConnection()` JDBC 2.0 Returns the `Connection` object that produced this `Statement` object.
`int` | `getFetchDirection()` JDBC 2.0 Retrieves the direction for fetching rows from database tables that is the default for result sets generated from this `Statement` object.
`int` | `getFetchSize()` JDBC 2.0 Retrieves the number of result set rows that is the default fetch size for result sets generated from this `Statement` object.
`int` | `getMaxFieldSize()` Returns the maximum number of bytes allowed for any column value.
`int` | `getMaxRows()` Retrieves the maximum number of rows that a ResultSet can contain.
`boolean` | `getMoreResults()` Moves to a Statement's next result.
`int` | `getQueryTimeout()` Retrieves the number of seconds the driver will wait for a Statement to execute.
`java.sql.ResultSet` | `getResultSet()` Returns the current result as a `ResultSet` object.
`int` | `getResultSetConcurrency()` JDBC 2.0 Retrieves the result set concurrency.
`int` | `getResultSetType()` JDBC 2.0 Determine the result set type.
`int` | `getUpdateCount()` Returns the current result as an update count; if the result is a ResultSet or there are no more results, -1 is returned.
`java.sql.SQLWarning` | `getWarnings()` Retrieves the first warning reported by calls on this Statement.
`void` | `setCursorName(java.lang.String name)` Defines the SQL cursor name that will be used by subsequent Statement `execute` methods.
`void` | `setEscapeProcessing(boolean enable)` Sets escape processing on or off.
`void` | `setFetchDirection(int direction)` JDBC 2.0 Gives the driver a hint as to the direction in which the rows in a result set will be processed.
`void` | `setFetchSize(int rows)` 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.
`void` | `setMaxFieldSize(int max)` Sets the limit for the maximum number of bytes in a column to the given number of bytes.
`void` | `setMaxRows(int max)` Sets the limit for the maximum number of rows that any ResultSet can contain to the given number.
`void` | `setQueryTimeout(int seconds)` Sets the number of seconds the driver will wait for a Statement to execute to the given number of seconds.

Methods inherited from class java.lang.Object
`, clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### jdbcStatement

    jdbcStatement(jdbcConnection c)

  Constructor declaration
  Parameters:
    `c` -
  See Also:

Method Detail

### executeQuery

    public java.sql.ResultSet executeQuery(java.lang.String sql)
                                    throws java.sql.SQLException

  Executes a SQL statement that returns a single ResultSet.
  Specified by:
    executeQuery in interface java.sql.Statement
  Parameters:
    `sql` - typically this is a static SQL SELECT statement
  Returns:
    a ResultSet that contains the data produced by the query; never null
  Throws:
    java.sql.SQLException - if a database access error occurs

### executeUpdate

    public int executeUpdate(java.lang.String sql)
                      throws java.sql.SQLException

  Executes an SQL INSERT, UPDATE or DELETE statement. In addition, SQL statements that return nothing, such as SQL DDL statements, can be executed.
  Specified by:
    executeUpdate in interface java.sql.Statement
  Parameters:
    `sql` - a SQL INSERT, UPDATE or DELETE statement or a SQL statement that returns nothing
  Returns:
    either the row count for INSERT, UPDATE or DELETE or 0 for SQL statements that return nothing
  Throws:
    java.sql.SQLException - if a database access error occurs

### close

    public void close()

  Releases this `Statement` 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.

  Note: A Statement is automatically closed when it is garbage collected. When a Statement is closed, its current ResultSet, if one exists, is also closed.

  Specified by:
    close in interface java.sql.Statement

### getMaxFieldSize

    public int getMaxFieldSize()

  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.

  In HSQL, field sizes are always unlimited.

  Specified by:
    getMaxFieldSize in interface java.sql.Statement
  Returns:
    the current max column size limit; zero means unlimited

### setMaxFieldSize

    public void setMaxFieldSize(int max)

  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.

  In HSQL, field sizes are always unlimited.

  Specified by:
    setMaxFieldSize in interface java.sql.Statement
  Parameters:
    `max` - the new max column size limit; zero means unlimited

### getMaxRows

    public int getMaxRows()

  Retrieves the maximum number of rows that a ResultSet can contain. If the limit is exceeded, the excess rows are silently dropped.
  Specified by:
    getMaxRows in interface java.sql.Statement
  Returns:
    the current max row limit; zero means unlimited

### setMaxRows

    public void setMaxRows(int max)

  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.
  Specified by:
    setMaxRows in interface java.sql.Statement
  Parameters:
    `max` - the new max rows limit; zero means unlimited

### setEscapeProcessing

    public void setEscapeProcessing(boolean enable)

  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.
  Specified by:
    setEscapeProcessing in interface java.sql.Statement
  Parameters:
    `enable` - true to enable; false to disable

### getQueryTimeout

    public int getQueryTimeout()

  Retrieves the number of seconds the driver will wait for a Statement to execute. If the limit is exceeded, a SQLException is thrown.

  HSQL currently does not support this feature. Queries that take 1 second are very seldom.

  Specified by:
    getQueryTimeout in interface java.sql.Statement
  Returns:
    the current query timeout limit in seconds; zero means unlimited

### setQueryTimeout

    public void setQueryTimeout(int seconds)

  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.

  HSQL currently does not support this feature. Queries that take 1 second are very seldom.

  Specified by:
    setQueryTimeout in interface java.sql.Statement
  Parameters:
    `seconds` - the new query timeout limit in seconds; zero means unlimited

### cancel

    public void cancel()

  Cancels this `Statement` 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.

  HSQL currently does not support this feature.

  Specified by:
    cancel in interface java.sql.Statement

### getWarnings

    public java.sql.SQLWarning getWarnings()

  Retrieves the first warning reported by calls on this Statement. Subsequent Statement warnings will be chained to this SQLWarning.

  The warning chain is automatically cleared each time a statement is (re)executed.

  Note: If you are processing a ResultSet, any warnings associated with ResultSet reads will be chained on the ResultSet object.

  HSQL never produces warnings and returns always null.

  Specified by:
    getWarnings in interface java.sql.Statement
  Returns:
    the first SQLWarning or null

### clearWarnings

    public void clearWarnings()

  Clears all the warnings reported on this `Statement` object. After a call to this method, the method `getWarnings` will return null until a new warning is reported for this Statement.
  Specified by:
    clearWarnings in interface java.sql.Statement

### setCursorName

    public void setCursorName(java.lang.String name)

  Defines the SQL cursor name that will be used by subsequent Statement `execute` 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.

  HSQL currently does not support this feature.

  Note: 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.

  Specified by:
    setCursorName in interface java.sql.Statement
  Parameters:
    `name` - the new cursor name, which must be unique within a connection

### execute

    public boolean execute(java.lang.String sql)
                    throws java.sql.SQLException

  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 `execute`, `getMoreResults`, `getResultSet`, and `getUpdateCount` let you navigate through multiple results. The `execute` 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).
  Specified by:
    execute in interface java.sql.Statement
  Parameters:
    `sql` - any SQL statement
  Returns:
    true if the next result is a ResultSet; false if it is an update count or there are no more results
  Throws:
    java.sql.SQLException - if a database access error occurs
  See Also:
    `getResultSet()`, `getUpdateCount()`, `getMoreResults()`

### getResultSet

    public java.sql.ResultSet getResultSet()

  Returns the current result as a `ResultSet` object. This method should be called only once per result.
  Specified by:
    getResultSet in interface java.sql.Statement
  Returns:
    the current result as a ResultSet; null if the result is an update count or there are no more results
  See Also:
    `execute(java.lang.String)`

### getUpdateCount

    public int getUpdateCount()

  Returns the current result as an update count; if the result is a ResultSet or there are no more results, -1 is returned. This method should be called only once per result.
  Specified by:
    getUpdateCount in interface java.sql.Statement
  Returns:
    the current result as an update count; -1 if it is a ResultSet or there are no more results
  See Also:
    `execute(java.lang.String)`

### getMoreResults

    public boolean getMoreResults()

  Moves to a Statement's next result. It returns true if this result is a ResultSet. This method also implicitly closes any current ResultSet obtained with getResultSet. There are no more results when (!getMoreResults() && (getUpdateCount() == -1)

  HSQL currently does not support multiple ResultSets.

  Specified by:
    getMoreResults in interface java.sql.Statement
  Returns:
    true if the next result is a ResultSet; false if it is an update count or there are no more results
  See Also:
    `execute(java.lang.String)`

### setFetchDirection

    public void setFetchDirection(int direction)
                           throws java.sql.SQLException

  JDBC 2.0 Gives the driver a hint as to the direction in which the rows in a result set will be processed. The hint applies only to result sets created using this Statement object. The default value is ResultSet.FETCH_FORWARD.

  Note that this method sets the default fetch direction for result sets generated by this `Statement` object. Each result set has its own methods for getting and setting its own fetch direction.

  Specified by:
    setFetchDirection in interface java.sql.Statement
  Parameters:
    `direction` - the initial direction for processing rows
  Throws:
    java.sql.SQLException - if a database access error occurs or the given direction is not one of ResultSet.FETCH_FORWARD, ResultSet.FETCH_REVERSE, or ResultSet.FETCH_UNKNOWN

### getFetchDirection

    public int getFetchDirection()

  JDBC 2.0 Retrieves the direction for fetching rows from database tables that is the default for result sets generated from this `Statement` object. If this `Statement` object has not set a fetch direction by calling the method `setFetchDirection`, the return value is implementation-specific.
  Specified by:
    getFetchDirection in interface java.sql.Statement
  Returns:
    the default fetch direction for result sets generated from this `Statement` object

### setFetchSize

    public void setFetchSize(int rows)

  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. The number of rows specified affects only result sets created using this statement. If the value specified is zero, then the hint is ignored. The default value is zero.
  Specified by:
    setFetchSize in interface java.sql.Statement
  Parameters:
    `rows` - the number of rows to fetch condition 0 <= rows <= this.getMaxRows() is not satisfied.

### getFetchSize

    public int getFetchSize()

  JDBC 2.0 Retrieves the number of result set rows that is the default fetch size for result sets generated from this `Statement` object. If this `Statement` object has not set a fetch size by calling the method `setFetchSize`, the return value is implementation-specific.
  Specified by:
    getFetchSize in interface java.sql.Statement
  Returns:
    the default fetch size for result sets generated from this `Statement` object

### getResultSetConcurrency

    public int getResultSetConcurrency()

  JDBC 2.0 Retrieves the result set concurrency.
  Specified by:
    getResultSetConcurrency in interface java.sql.Statement

### getResultSetType

    public int getResultSetType()

  JDBC 2.0 Determine the result set type.
  Specified by:
    getResultSetType in interface java.sql.Statement

### addBatch

    public void addBatch(java.lang.String sql)
                  throws java.sql.SQLException

  JDBC 2.0 Adds a SQL command to the current batch of commmands for the statement. This method is optional.

  HSQL currently does not support this feature because there is no performance win in using batches.

  Specified by:
    addBatch in interface java.sql.Statement
  Parameters:
    `sql` - typically this is a static SQL INSERT or UPDATE statement
  Throws:
    java.sql.SQLException - if a database access error occurs, or the driver does not support batch statements

### clearBatch

    public void clearBatch()
                    throws java.sql.SQLException

  JDBC 2.0 Makes the set of commands in the current batch empty. This method is optional.
  Specified by:
    clearBatch in interface java.sql.Statement
  Throws:
    java.sql.SQLException - if a database access error occurs or the driver does not support batch statements

### executeBatch

    public int[] executeBatch()
                       throws java.sql.SQLException

  JDBC 2.0 Submits a batch of commands to the database for execution. This method is optional.
  Specified by:
    executeBatch in interface java.sql.Statement
  Returns:
    an array of update counts containing one element for each command in the batch. The array is ordered according to the order in which commands were inserted into the batch.
  Throws:
    java.sql.SQLException - if a database access error occurs or the driver does not support batch statements

### getConnection

    public java.sql.Connection getConnection()

  JDBC 2.0 Returns the `Connection` object that produced this `Statement` object.
  Specified by:
    getConnection in interface java.sql.Statement
  Returns:
    the connection that produced this statement

Package | Class | Tree | Deprecated
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD