Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
    /*
    * Firebird Open Source J2ee connector - jdbc driver
    *
    * Distributable under LGPL license.
    * You may obtain a copy of the License at http://www.gnu.org/copyleft/lgpl.html
    *
    * This program is distributed in the hope that it will be useful,
    * but WITHOUT ANY WARRANTY; without even the implied warranty of
    * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * LGPL License for more details.
   *
   * This file was created by members of the firebird development team.
   * All individual contributions remain the Copyright (C) of those
   * individuals.  Contributors to this file are either listed here or
   * can be obtained from a CVS history command.
   *
   * All rights reserved.
   */
  
  package org.firebirdsql.jdbc;
  
  
  import java.sql.*;
  import java.util.*;
  

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

Only one ResultSet object per Statement object can be open at any point in time. Therefore, if the reading of one ResultSet object is interleaved with the reading of another, each must have been generated by different Statement objects. All statement execute methods implicitly close a statment's current ResultSet object if an open one exists.

  
  public abstract class AbstractStatement implements FirebirdStatementSynchronizable {
      
      protected GDSHelper gdsHelper;
  
      protected AbstractIscStmtHandle fixedStmt;
      
      //The normally retrieved resultset. (no autocommit, not a cached rs).
      private FBResultSet currentRs;
  
      private boolean closed;
      protected boolean completed = true;
      private boolean escapedProcessing = true;
      private volatile boolean closeOnCompletion = false;
  
  	 protected SQLWarning firstWarning = null;
  
  	 // If the last executedStatement returns ResultSet or UpdateCount
  	protected boolean isResultSet;
      protected boolean hasMoreResults;
  
      protected int maxRows = 0;	 
      protected int fetchSize = 0;
      private int maxFieldSize = 0;
      private int queryTimeout = 0;
      private String cursorName;
  
      private int rsConcurrency;
      private int rsType;
      private int rsHoldability = .;
      
  
      private AbstractConnection connection;

    
Listener for the result sets.
  
      private class RSListener implements FBObjectListener.ResultSetListener {
        
        
Notify that result set was closed. This method cleans the result set reference, so that call to AbstractStatement.close() method will not cause exception.

Parameters:
rs result set that was closed.
  
          public void resultSetClosed(ResultSet rsthrows SQLException {
               = null;
              
              // notify listener that statement is completed.
              notifyStatementCompleted();
              if () {
                  close();
             }
         }
         
         
         /* (non-Javadoc)
          * @see org.firebirdsql.jdbc.FBObjectListener.ResultSetListener#allRowsFetched(java.sql.ResultSet)
          */
         public void allRowsFetched(ResultSet rsthrows SQLException {
             
             /* 
              * According to the JDBC 3.0 specification (p.62) the result set
              * is closed in the autocommit mode if one of the following occurs: 
              * 
              * - all of the rows have been retrieved
              * - the associated Statement object is re-executed
              * - another Statement object is executed on the same connection
              */
             
             // according to the specification we close the result set and 
             // generate the "resultSetClosed" event, that in turn generates
             // the "statementCompleted" event
             
             if (.getConnection().getAutoCommit())
                 rs.close();
         }
 
 
         /* (non-Javadoc)
          * @see org.firebirdsql.jdbc.FBObjectListener.ResultSetListener#executionCompleted(org.firebirdsql.jdbc.FirebirdRowUpdater, boolean)
          */
         public void executionCompleted(FirebirdRowUpdater updaterboolean successthrows SQLException {
             notifyStatementCompleted(success);
         }
 
 
         /* (non-Javadoc)
          * @see org.firebirdsql.jdbc.FBObjectListener.ResultSetListener#executionStarted(org.firebirdsql.jdbc.FirebirdRowUpdater)
          */
         public void executionStarted(FirebirdRowUpdater updaterthrows SQLException {
             notifyStatementStarted(false);
         }
     }
 
     protected AbstractStatement(GDSHelper cint rsTypeint rsConcurrencyint rsHoldabilityFBObjectListener.StatementListener statementListenerthrows SQLException {
         this. = c;
         
         this. = rsConcurrency;
         this. = rsType;
         this. = rsHoldability;
         
         this. = statementListener;
         
         this. = statementListener != null ? 
                 statementListener.getConnection() : null;
         
          = false;
     }
     
     String getCursorName() {
         return ;
     }
     
     public boolean isValid() {
         return ! && ( == null || .isValid());
     }
    
    
Get synchronization object for this statement object.

Returns:
object that will be used for synchronization.
Throws:
java.sql.SQLException if something went wrong.
 
     public Object getSynchronizationObject() throws SQLException {
         // TODO: Has potential race condition
         
         if ( == null)
             return this;
         
         if (.getAutoCommit()) 
             return ;
         else
             return this;
     }
     
     protected void finalize() throws Throwable {
         if (!)
             close();
     }
     
     public void completeStatement() throws SQLException {
     }
     
     public void completeStatement(CompletionReason reasonthrows SQLException {
     	if ( != null && (reason != . || .getHoldability() == .)) {
     	    closeResultSet(false);
     	}
         
         if (!)
             notifyStatementCompleted();
     }
    
    
Executes an SQL statement that returns a single ResultSet object.

Parameters:
sql typically this is a static SQL SELECT statement
Returns:
a ResultSet object that contains the data produced by the given query; never null
Throws:
java.sql.SQLException if a database access error occurs
 
     public ResultSet executeQuery(String sqlthrows  SQLException {
         checkValidity();
 
         Object syncObject = getSynchronizationObject();
         synchronized(syncObject) {
             notifyStatementStarted();
 
             try {
                 if (!internalExecute(sql)) {
                     throw new FBSQLException(
                         "Query did not return a result set.",
                         .);
                 }
 
                 return getResultSet();
                 
             } catch (GDSException ge) {
                 throw new FBSQLException(ge);
             }
         }
     }
 
     protected void notifyStatementStarted() throws SQLException {
         notifyStatementStarted(true);
     }
     
     protected void notifyStatementStarted(boolean closeResultSetthrows SQLException {
         if (closeResultSet)
             closeResultSet(false);
         
         // notify listener that statement execution is about to start
         .executionStarted(this);
         
          = false;
     }
 
     protected void notifyStatementCompleted() throws SQLException {
         notifyStatementCompleted(true);
     }
     
     protected void notifyStatementCompleted(boolean successthrows SQLException {
          = true;
         .statementCompleted(thissuccess);
     }
    
    
Executes an SQL INSERT, UPDATE or DELETE statement. In addition, SQL statements that return nothing, such as SQL DDL statements, can be executed.

Parameters:
sql an SQL INSERT, UPDATE or DELETE statement or an SQL statement that returns nothing
Returns:
either the row count for INSERT, UPDATE or DELETE statements, or 0 for SQL statements that return nothing
Throws:
java.sql.SQLException if a database access error occurs
 
     public int executeUpdate(String sqlthrows SQLException {
         checkValidity();
         Object syncObject = getSynchronizationObject();
         synchronized (syncObject) {
 
             notifyStatementStarted();
             try {
                 try {
                     if (internalExecute(sql)) { throw new FBSQLException(
                             "Update statement returned results."); }
                     return getUpdateCount();
                 } catch (GDSException ge) {
                     throw new FBSQLException(ge);
                 }
             } finally {
                 notifyStatementCompleted();
             }
         }
     }
    
    
Executes the given SQL statement and signals the driver with the given flag about whether the auto-generated keys produced by this Statement object should be made available for retrieval. The driver will ignore the flag if the SQL statement is not an INSERT statement, or an SQL statement able to return auto-generated keys (the list of such statements is vendor-specific).

Parameters:
sql an SQL Data Manipulation Language (DML) statement, such as INSERT, UPDATE or DELETE; or an SQL statement that returns nothing, such as a DDL statement.
autoGeneratedKeys a flag indicating whether auto-generated keys should be made available for retrieval; one of the following constants: Statement.RETURN_GENERATED_KEYS Statement.NO_GENERATED_KEYS
Returns:
either (1) the row count for SQL Data Manipulation Language (DML) statements or (2) 0 for SQL statements that return nothing
Throws:
java.sql.SQLException if a database access error occurs, this method is called on a closed Statement, the given SQL statement returns a ResultSet object, or the given constant is not one of those allowed
java.sql.SQLFeatureNotSupportedException if the JDBC driver does not support this method with a constant of Statement.RETURN_GENERATED_KEYS
Since:
1.4
 
     public int executeUpdate(String sqlint autoGeneratedKeys)
             throws SQLException {
         
         execute(sqlautoGeneratedKeys);
         return getUpdateCount();
     }

    
Executes the given SQL statement and signals the driver that the auto-generated keys indicated in the given array should be made available for retrieval. This array contains the indexes of the columns in the target table that contain the auto-generated keys that should be made available. The driver will ignore the array if the SQL statement is not an INSERT statement, or an SQL statement able to return auto-generated keys (the list of such statements is vendor-specific).

Parameters:
sql an SQL Data Manipulation Language (DML) statement, such as INSERT, UPDATE or DELETE; or an SQL statement that returns nothing, such as a DDL statement.
columnIndexes an array of column indexes indicating the columns that should be returned from the inserted row
Returns:
either (1) the row count for SQL Data Manipulation Language (DML) statements or (2) 0 for SQL statements that return nothing
Throws:
java.sql.SQLException if a database access error occurs, this method is called on a closed Statement, the SQL statement returns a ResultSet object, or the second argument supplied to this method is not an int array whose elements are valid column indexes
java.sql.SQLFeatureNotSupportedException if the JDBC driver does not support this method
Since:
1.4
 
     public int executeUpdate(String sqlint[] columnIndexes)
             throws SQLException {
         
         execute(sqlcolumnIndexes);
         return getUpdateCount();
     }
    
    
Executes the given SQL statement and signals the driver that the auto-generated keys indicated in the given array should be made available for retrieval. This array contains the names of the columns in the target table that contain the auto-generated keys that should be made available. The driver will ignore the array if the SQL statement is not an INSERT statement, or an SQL statement able to return auto-generated keys (the list of such statements is vendor-specific).

Parameters:
sql an SQL Data Manipulation Language (DML) statement, such as INSERT, UPDATE or DELETE; or an SQL statement that returns nothing, such as a DDL statement.
columnNames an array of the names of the columns that should be returned from the inserted row
Returns:
either the row count for INSERT, UPDATE, or DELETE statements, or 0 for SQL statements that return nothing
Throws:
java.sql.SQLException if a database access error occurs, this method is called on a closed Statement, the SQL statement returns a ResultSet object, or the second argument supplied to this method is not a String array whose elements are valid column names
java.sql.SQLFeatureNotSupportedException if the JDBC driver does not support this method
Since:
1.4
 
     public int executeUpdate(String sqlString[] columnNames)
             throws SQLException {
         execute(sqlcolumnNames);
         return getUpdateCount();
     }
    
    
Executes the given SQL statement, which may return multiple results, and signals the driver that any auto-generated keys should be made available for retrieval. The driver will ignore this signal if the SQL statement is not an INSERT statement, or an SQL statement able to return auto-generated keys (the list of such statements is vendor-specific).

In 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 execute method executes an SQL statement and indicates the form of the first result. You must then use the methods getResultSet or getUpdateCount to retrieve the result, and getMoreResults to move to any subsequent result(s).

Parameters:
sql any SQL statement
autoGeneratedKeys a constant indicating whether auto-generated keys should be made available for retrieval using the method getGeneratedKeys; one of the following constants: Statement.RETURN_GENERATED_KEYS or Statement.NO_GENERATED_KEYS
Returns:
true if the first result is a ResultSet object; false if it is an update count or there are no results
Throws:
java.sql.SQLException if a database access error occurs, this method is called on a closed Statement or the second parameter supplied to this method is not Statement.RETURN_GENERATED_KEYS or Statement.NO_GENERATED_KEYS.
java.sql.SQLFeatureNotSupportedException if the JDBC driver does not support this method with a constant of Statement.RETURN_GENERATED_KEYS
Since:
1.4
See also:
getResultSet()
getUpdateCount()
getMoreResults()
getGeneratedKeys()
 
     public boolean execute(String sqlint autoGeneratedKeys)
             throws SQLException {
         
         checkValidity();
         if (autoGeneratedKeys == .) {
             .checkAutoGeneratedKeysSupport();
         }
 
         AbstractGeneratedKeysQuery query = .new GeneratedKeysQuery(sqlautoGeneratedKeys); 
         return execute(query.getQueryString());
     }

    
Executes the given SQL statement, which may return multiple results, and signals the driver that the auto-generated keys indicated in the given array should be made available for retrieval. This array contains the indexes of the columns in the target table that contain the auto-generated keys that should be made available. The driver will ignore the array if the SQL statement is not an INSERT statement, or an SQL statement able to return auto-generated keys (the list of such statements is vendor-specific).

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 execute method executes an SQL statement and indicates the form of the first result. You must then use the methods getResultSet or getUpdateCount to retrieve the result, and getMoreResults to move to any subsequent result(s).

Parameters:
sql any SQL statement
columnIndexes an array of the indexes of the columns in the inserted row that should be made available for retrieval by a call to the method getGeneratedKeys
Returns:
true if the first result is a ResultSet object; false if it is an update count or there are no results
Throws:
java.sql.SQLException if a database access error occurs, this method is called on a closed Statement or the elements in the int array passed to this method are not valid column indexes
java.sql.SQLFeatureNotSupportedException if the JDBC driver does not support this method
Since:
1.4
See also:
getResultSet()
getUpdateCount()
getMoreResults()
 
     public boolean execute(String sqlint[] columnIndexesthrows SQLException {
         checkValidity();
         
         AbstractGeneratedKeysQuery query = .new GeneratedKeysQuery(sqlcolumnIndexes); 
         return execute(query.getQueryString());
     }

    
Executes the given SQL statement, which may return multiple results, and signals the driver that the auto-generated keys indicated in the given array should be made available for retrieval. This array contains the names of the columns in the target table that contain the auto-generated keys that should be made available. The driver will ignore the array if the SQL statement is not an INSERT statement, or an SQL statement able to return auto-generated keys (the list of such statements is vendor-specific).

In 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 execute method executes an SQL statement and indicates the form of the first result. You must then use the methods getResultSet or getUpdateCount to retrieve the result, and getMoreResults to move to any subsequent result(s).

Parameters:
sql any SQL statement
columnNames an array of the names of the columns in the inserted row that should be made available for retrieval by a call to the method getGeneratedKeys
Returns:
true if the next result is a ResultSet object; false if it is an update count or there are no more results
Throws:
java.sql.SQLException if a database access error occurs, this method is called on a closed Statement or the elements of the String array passed to this method are not valid column names
java.sql.SQLFeatureNotSupportedException if the JDBC driver does not support this method
Since:
1.4
See also:
getResultSet()
getUpdateCount()
getMoreResults()
getGeneratedKeys()
 
     public boolean execute(String sqlString[] columnNames)
             throws SQLException {
         checkValidity();
         
         AbstractGeneratedKeysQuery query = .new GeneratedKeysQuery(sqlcolumnNames); 
         return execute(query.getQueryString());
     }

    
Retrieves any auto-generated keys created as a result of executing this Statement object. If this Statement object did not generate any keys, an empty ResultSet object is returned.

Note:If the columns which represent the auto-generated keys were not specified, the JDBC driver implementation will determine the columns which best represent the auto-generated keys.

Returns:
a ResultSet object containing the auto-generated key(s) generated by the execution of this Statement object
Throws:
java.sql.SQLException if a database access error occurs or this method is called on a closed Statement
java.sql.SQLFeatureNotSupportedException if the JDBC driver does not support this method
Since:
1.4
 
     public ResultSet getGeneratedKeys() throws SQLException {
         checkValidity();
         ResultSet rs = getResultSet();
         if (rs == null) {
             rs = new FBResultSet(new XSQLVAR[0], new ArrayList());
         }
         return rs;
     }

    
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.

Calling the method close on a Statement object that is already closed has no effect.

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

Throws:
java.sql.SQLException if a database access error occurs
 
     public void close() throws  SQLException {
         close(true);
     }
     
     void close(boolean ignoreAlreadyClosedthrows SQLException {
         if (isClosed()) { 
             if (ignoreAlreadyClosed)
                 return;
             
             throw new FBSQLException("This statement is already closed.");
         }
             
         Object syncObject = getSynchronizationObject();
         
         synchronized(syncObject) {
             if ( != null) {
                 try {
                     try {
                         closeResultSet(false);
                     } finally {
                         //may need ensureTransaction?
                         if (.isValid())
                             .closeStatement(true);
                     }
                 } catch (GDSException ge) {
                     throw new FBSQLException(ge);
                 } finally {
                      = null;
                 }
             } 
         }
 
          = true;
         .statementClosed(this);
     }
    
    
Check if this statement was closed. This is quick workaround to avoid additional close() in our cleanup code.

Returns:
true if this statement was already closed.
 
     public boolean isClosed() {
         return ;
     }
 
 
     //----------------------------------------------------------------------
 
    
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.

Returns:
the current max column size limit; zero means unlimited
Throws:
java.sql.SQLException if a database access error occurs
 
     public int getMaxFieldSize() throws  SQLException {
         return ;
     }


    
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.

Parameters:
max the new max column size limit; zero means unlimited
Throws:
java.sql.SQLException if a database access error occurs
 
     public void setMaxFieldSize(int maxthrows  SQLException {
         if (max<0)
             throw new FBSQLException("Can't set max field size negative",
                     .);
         else
              = max;
     }


    
Retrieves the maximum number of rows that a ResultSet object can contain. If the limit is exceeded, the excess rows are silently dropped.

Returns:
the current max row limit; zero means unlimited
Throws:
java.sql.SQLException if a database access error occurs
 
     public int getMaxRows() throws  SQLException {
         return ;
     }


    
Sets the limit for the maximum number of rows that any ResultSet object can contain to the given number. If the limit is exceeded, the excess rows are silently dropped.

Parameters:
max the new max rows limit; zero means unlimited
Throws:
java.sql.SQLException if a database access error occurs
 
     public void setMaxRows(int maxthrows  SQLException {
         if (max<0)
             throw new FBSQLException("Max rows can't be less than 0",
                     .);
         else
              = 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.

Parameters:
enable true to enable; false to disable
Throws:
java.sql.SQLException if a database access error occurs
 
     public void setEscapeProcessing(boolean enablethrows  SQLException {
          = enable;
     }


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

Returns:
the current query timeout limit in seconds; zero means unlimited
Throws:
java.sql.SQLException if a database access error occurs
 
     public int getQueryTimeout() throws  SQLException {
         return ;
     }


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

Parameters:
seconds the new query timeout limit in seconds; zero means unlimited
Throws:
java.sql.SQLException if a database access error occurs
 
     public void setQueryTimeout(int secondsthrows  SQLException {
         if (seconds<0)
             throw new FBSQLException("Can't set query timeout negative",
                     .);
         else
              = seconds;
     }


    
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.

Throws:
java.sql.SQLException if a database access error occurs
 
     public void cancel() throws  SQLException {
         try {
             .cancelOperation();
         } catch(GDSException ex) {
             throw new FBSQLException(ex);
         }
     }


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

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

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

Returns:
the first SQLWarning object or null
Throws:
java.sql.SQLException if a database access error occurs
 
     public SQLWarning getWarnings() throws  SQLException {
         return ;
     }


    
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 object.

Throws:
java.sql.SQLException if a database access error occurs
 
     public void clearWarnings() throws  SQLException {
          = null;
     }


    
Defines the SQL cursor name that will be used by subsequent Statement object execute methods. This name can then be used in SQL positioned update/delete statements to identify the current row in the ResultSet object 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.

Note: By definition, positioned update/delete execution must be done by a different Statement object than the one which generated the ResultSet object being used for positioning. Also, cursor names must be unique within a connection.

Parameters:
name the new cursor name, which must be unique within a connection
Throws:
java.sql.SQLException if a database access error occurs
 
     public void setCursorName(String namethrows  SQLException {
         this. = name;
     }
 
     boolean isUpdatableCursor() {
         return  != null;
     }
 
     //----------------------- Multiple Results --------------------------
 
    
Executes an 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 an SQL statement and indicates the form of the first result. You can then use the methods getResultSet or getUpdateCount to retrieve the result, and getMoreResults to move to any subsequent result(s).

Parameters:
sql any SQL statement
Returns:
true if the next result is a ResultSet object; 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()
 
     public boolean execute(String sqlthrows SQLException {
         checkValidity();
 
         Object syncObject = getSynchronizationObject();
         synchronized (syncObject) {
             notifyStatementStarted();
 
             boolean hasResultSet = false;
             try {
                 try {
                     hasResultSet = internalExecute(sql);
                 } catch (GDSException ge) {
                     throw new FBSQLException(ge);
                 }
             } finally {
                 if (!hasResultSet) {
                     notifyStatementCompleted();
                 }
 
             }
             return hasResultSet;
 
         }
     }

    
Returns the current result as a ResultSet object. This method should be called only once per result. Calling this method twice with autocommit on and used will probably throw an inappropriate or uninformative exception.

Returns:
the current result as a ResultSet object; null if the result is an update count or there are no more results
Throws:
java.sql.SQLException if a database access error occurs
See also:
execute(java.lang.String)
 
     public ResultSet getResultSet() throws SQLException {
         return getResultSet(false);
     }
     public ResultSet getResultSet(boolean metaDataQuerythrows  SQLException {
         try {
             if ( != null)
                 .setCursorName();
         } catch(GDSException ex) {
             throw new FBSQLException(ex);
         }
         
         
         if ( != null) {
             throw new FBSQLException("Only one resultset at a time/statement.");
         }
         if ( == null) {
             throw new FBSQLException("No statement was executed.");
         }
         else {
             if () {
                  = new FBResultSet(this,
                         metaDataQuery
                         false);
                 
                 return ;
             } else
                 return null;
         } // end of else
     }
 
 	public boolean hasOpenResultSet() {
 		return  != null;
 	}

    
Returns the current result as an update count; if the result is a ResultSet object or there are no more results, -1 is returned. This method should be called only once per result.

Returns:
the current result as an update count; -1 if the current result is a ResultSet object or there are no more results
Throws:
java.sql.SQLException if a database access error occurs
See also:
execute(java.lang.String)
 
     public int getUpdateCount() throws  SQLException {
         if ( || !)
             return -1;
         else {
             try {
                 .getSqlCounts();
                 int insCount = .getInsertCount();
                 int updCount = .getUpdateCount();
                 int delCount = .getDeleteCount();
                 int resCount = ((updCount>delCount) ? updCount:delCount);
                 resCount = ((resCount>insCount) ? resCount:insCount);
                 return resCount;
             }
             catch (GDSException ge) {
                 throw new FBSQLException(ge);
             } finally {
                  = false;
             }
         }
     }
 
     private static final int INSERTED_ROWS_COUNT = 1;
     private static final int UPDATED_ROWS_COUNT = 2;
     private static final int DELETED_ROWS_COUNT = 3;
     
 	private int getChangedRowsCount(int typethrows SQLException {
         if ( || !)
             return -1;
         else {
         	try {
         		.getSqlCounts();
                 switch(type) {
                     case  :
                     	return .getInsertCount();
                     case  :
                         return .getUpdateCount();
                     case  :
                         return .getDeleteCount();
                     default :
                         throw new IllegalArgumentException(
                             "Specified type is unknown.");
                 }
             } catch(GDSException ex) {
             	throw new FBSQLException(ex);
             }
         }
 	}
     
     public int getDeletedRowsCount() throws SQLException {
     }
 
 	public int getInsertedRowsCount() throws SQLException {
 	}
 
 	public int getUpdatedRowsCount() throws SQLException {
 	}

    
Moves to a Statement object's next result. It returns true if this result is a ResultSet object. This method also implicitly closes any current ResultSet object obtained with the method getResultSet.

There are no more results when the following is true:

      (!getMoreResults() && (getUpdateCount() == -1)
 

Returns:
true if the next result is a ResultSet object; 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:
execute(java.lang.String)
    public boolean getMoreResults() throws  SQLException {
    }
        
    public boolean getMoreResults(int modethrows SQLException {
         = false;
        boolean closeResultSet = mode == .
                || mode == .;
        
        if (closeResultSet &&  != null) {
            closeResultSet(true);
        }
        
        return ;
    }
    //--------------------------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.

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
Since:
1.2
See also:
What Is in the JDBC 2.0 API
    public void setFetchDirection(int directionthrows  SQLException {
        if (direction != .)
            throw new FBDriverNotCapableException();
    }


    
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.

Returns:
the default fetch direction for result sets generated from this Statement object
Throws:
java.sql.SQLException if a database access error occurs
Since:
1.2
See also:
What Is in the JDBC 2.0 API
    public int getFetchDirection() throws  SQLException {
       return .;
    }


    
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.

Parameters:
rows the number of rows to fetch
Throws:
java.sql.SQLException if a database access error occurs, or the condition 0 <= rows <= this.getMaxRows() is not satisfied.
Since:
1.2
See also:
What Is in the JDBC 2.0 API
    public void setFetchSize(int rowsthrows  SQLException {
        if (rows < 0)
            throw new FBSQLException("Can't set negative fetch size",
                    .);
        else if ( > 0 && rows > )
            throw new FBSQLException("Can't set fetch size > maxRows",
                    .);
        else
             = rows;
    }


    
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.

Returns:
the default fetch size for result sets generated from this Statement object
Throws:
java.sql.SQLException if a database access error occurs
Since:
1.2
See also:
What Is in the JDBC 2.0 API
    public int getFetchSize() throws  SQLException {
        return ;
    }


    
Retrieves the result set concurrency for ResultSet objects generated by this Statement object.

Returns:
either ResultSet.CONCUR_READ_ONLY or ResultSet.CONCUR_UPDATABLE
Since:
1.2
See also:
What Is in the JDBC 2.0 API
    public int getResultSetConcurrency() throws  SQLException {
        return ;
    }


    
Retrieves the result set type for ResultSet objects generated by this Statement object.

Returns:
one of ResultSet.TYPE_FORWARD_ONLY, ResultSet.TYPE_SCROLL_INSENSITIVE, or ResultSet.TYPE_SCROLL_SENSITIVE
Since:
1.2
See also:
What Is in the JDBC 2.0 API
    public int getResultSetType()  throws  SQLException {
        return ;
    }
    
    
Retrieves the result set holdability for ResultSet objects generated by this Statement object.

    public int getResultSetHoldability() throws SQLException {
        return ;
    }
    private LinkedList batchList = new LinkedList();

    
Adds an SQL command to the current batch of commmands for this Statement object. This method is optional.

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
Since:
1.2
See also:
What Is in the JDBC 2.0 API
    public void addBatchString sql ) throws  SQLException {
        .add(sql);
    }


    
Makes the set of commands in the current batch empty. This method is optional.

Throws:
java.sql.SQLException if a database access error occurs or the driver does not support batch statements
Since:
1.2
See also:
What Is in the JDBC 2.0 API
    public void clearBatch() throws  SQLException {
        .clear();
    }


    
Submits a batch of commands to the database for execution and if all commands execute successfully, returns an array of update counts. The int elements of the array that is returned are ordered to correspond to the commands in the batch, which are ordered according to the order in which they were added to the batch. The elements in the array returned by the method executeBatch may be one of the following:
  1. A number greater than or equal to zero -- indicates that the command was processed successfully and is an update count giving the number of rows in the database that were affected by the command's execution
  2. A value of -2 -- indicates that the command was processed successfully but that the number of rows affected is unknown

    If one of the commands in a batch update fails to execute properly, this method throws a BatchUpdateException, and a JDBC driver may or may not continue to process the remaining commands in the batch. However, the driver's behavior must be consistent with a particular DBMS, either always continuing to process commands or never continuing to process commands. If the driver continues processing after a failure, the array returned by the method BatchUpdateException.getUpdateCounts will contain as many elements as there are commands in the batch, and at least one of the elements will be the following:

  3. A value of -3 -- indicates that the command failed to execute successfully and occurs only if a driver continues to process commands after a command fails

A driver is not required to implement this method. The possible implementations and return values have been modified in the Java 2 SDK, Standard Edition, version 1.3 to accommodate the option of continuing to proccess commands in a batch update after a BatchUpdateException obejct has been thrown.

Returns:
an array of update counts containing one element for each command in the batch. The elements of the array are ordered according to the order in which commands were added to the batch.
Throws:
java.sql.SQLException if a database access error occurs or the driver does not support batch statements. Throws java.sql.BatchUpdateException (a subclass of SQLException) if one of the commands sent to the database fails to execute properly or attempts to return a result set.
Since:
1.3
See also:
What Is in the JDBC 2.0 API
    public int[] executeBatch() throws SQLException {
        checkValidity();
            addWarning(new SQLWarning("Batch updates should be run "
                    + "with auto-commit disabled.""1000"));
        Object syncObject = getSynchronizationObject();
        notifyStatementStarted();
        synchronized (syncObject) {
            boolean success = false;
            try {
            	LinkedList responses = new LinkedList();
                try {
                    Iterator iter = .iterator();
                    while (iter.hasNext()) {
                        String sql = (Stringiter.next();
                        try {
                            boolean hasResultSet = internalExecute(sql);
                            if (hasResultSet)
                                throw new BatchUpdateException(
                                        toArray(responses));
                            else
                                responses.add(new Integer(getUpdateCount()));
                        } catch (GDSException ge) {
                            throw new BatchUpdateException(ge.getMessage(),
                                    .ge
                                            .getFbErrorCode(),
                                    toArray(responses));
                        }
                    }
                    success = true;
                    return toArray(responses);
                } finally {
                    clearBatch();
                }
            } finally {
                notifyStatementCompleted(success);
            }
        }
    }
    
    
Convert collection of java.lang.Integer elements into array of int.

Parameters:
list collection of integer elements.
Returns:
array of int.
    protected int[] toArray(Collection list) {
        int[] result = new int[list.size()];
        int counter = 0;
        Iterator iter = list.iterator();
        while(iter.hasNext()) {
        	result[counter++] = ((Integer)iter.next()).intValue();
        }
        return result;
    }


    
Returns the Connection object that produced this Statement object.

Returns:
the connection that produced this statement
    public Connection getConnection() throws SQLException {
        checkValidity();
        return ;
    }
    //package level
    void closeResultSet(boolean notifyListenerthrows SQLException {
        boolean wasCompleted = ;
        
        try {
            if ( != null) {
                try {
                    .close(notifyListener);
                } finally {
                     = null;
                }
            }
        } finally {
            if (notifyListener && !wasCompleted)
                .statementCompleted(this);
        }
    }
    
    public void forgetResultSet() { //yuck should be package
         = null;
        if ( != null) {
            .clearRows();
        }
    }
    
    public ResultSet getCurrentResultSet() throws SQLException {
        return ;
    }
    
    public boolean isPoolable() throws SQLException {
        checkValidity();
        return false;
    }
    public void setPoolable(boolean poolablethrows SQLException {
        checkValidity();
        // ignore the hint
    }
    
    public boolean isWrapperFor(Class<?> ifacethrows SQLException {
        return iface != null && iface.isAssignableFrom(getClass());
    }
    public <T> T unwrap(Class<T> ifacethrows SQLException {
        if (!isWrapperFor(iface))
            throw new FBDriverNotCapableException();
        
        return iface.cast(this);
    }
    
    // JDBC 4.1
    
    public void closeOnCompletion() {
         = true;
    }
    
    public boolean isCloseOnCompletion() {
        return ;
    }
     
    
This method checks if supplied statement is executing procedure or it is generic statement. This check is needed to handle correctly parameters that are returned from non-selectable procedures.

Parameters:
sql SQL statement to check
Returns:
true if supplied statement is EXECUTE PROCEDURE type of statement.
Throws:
java.sql.SQLException if translating statement into native code failed.
    protected boolean isExecuteProcedureStatement(String sqlthrows SQLException {
        
        String trimmedSql = nativeSQL(sql).trim();
        
        if (trimmedSql.startsWith("EXECUTE"))
            return true;
        else
            return false;
        
    }
    protected boolean internalExecute(String sql)
        throws GDSExceptionSQLException
    {
        if ()
            throw new FBSQLException("Statement is already closed.");
        // closeResultSet(false);
        prepareFixedStatement(sqlfalse);
         = true;
         = .getOutSqlda(). > 0;
        return ;
    }
    protected void prepareFixedStatement(String sqlboolean describeBind)
        throws GDSExceptionSQLException
    {
        if ( == null) {
             = .allocateStatement();
        }
        
        if (!.isValid())
            throw new FBSQLException("Corresponding connection is not valid.",
                .);
        
            
             ? nativeSQL(sql) : sql
            describeBind);
    }
    protected void addWarning(SQLWarning warning){
        if ( == null)
             = warning;
        else{
            SQLWarning lastWarning = ;
            while (lastWarning.getNextWarning() != null){
                lastWarning = lastWarning.getNextWarning();
            }
            lastWarning.setNextWarning(warning);
        }
    }
    protected String nativeSQL(String sqlthrows SQLException {
        
        int mode = .;
        
            mode = .;
        
        return new FBEscapedParser(mode).parse(sql);
    }


    
Get the execution plan of this PreparedStatement

Returns:
The execution plan of the statement
        populateStatementInfo();
        return .getExecutionPlan();
    }
    
    public String getLastExecutionPlan() throws SQLException {
        checkValidity();
        
        if ( == null)
            throw new FBSQLException("No statement was executed, plan cannot be obtained.");
        
        return getExecutionPlan();
    }

    
Get the statement type of this PreparedStatement. The returned value will be one of the TYPE_* constant values.

Returns:
The identifier for the given statement's type
    int getStatementType() throws FBSQLException {
        populateStatementInfo();
        return .getStatementType();
    }
    private void populateStatementInfo() throws FBSQLException {
        if (.getExecutionPlan() == null){
            try {
            } catch(GDSException ex) {
                throw new FBSQLException(ex);
            }
        }
    }
    
    
Check if this statement is valid. This method should be invoked before executing any action which requires a valid connection.

Throws:
java.sql.SQLException if this Statement has been closed and cannot be used anymore.
    protected void checkValidity() throws SQLException {
        if (isClosed())
            throw new FBSQLException("Statement is already closed.".);
    }
    
    
Reasons for statement completion. This is intended for the InternalTransactionCoordinator to notify the statement on why it should complete.

TODO: This is a bit of kludge to fix JDBC-304 in 2.2.x, might need some more polish for 2.3

Since:
2.2.3
    protected enum CompletionReason {
    	COMMIT,
    	OTHER;
    }
New to GrepCode? Check out our FAQ X