Derby - Class org.apache.derby.impl.sql.conn.GenericLanguageConnectionContext

   Licensed to the Apache Software Foundation (ASF) under one or more

   contributor license agreements.  See the NOTICE file distributed with

   this work for additional information regarding copyright ownership.

   The ASF licenses this file to you under the Apache License, Version 2.0

   (the "License"); you may not use this file except in compliance with

   the License.  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software

   distributed under the License is distributed on an "AS IS" BASIS,

   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

   See the License for the specific language governing permissions and

   limitations under the License.

*/

* LanguageConnectionContext keeps the pool of prepared statements,

* activations, and cursors in use by the current connection.

* <p>

* The generic impl does not provide statement caching.

*

* @author ames

*

*/

  extends ContextImpl

  implements LanguageConnectionContext

  // make sure these are not zeros

  private final static int NON_XA = 0;

  private final static int XA_ONE_PHASE = 1;

  private final static int XA_TWO_PHASE = 2;

  /*

    fields

   */

  private final Vector acts;

  private volatile boolean unusedActs=false;

  protected int bindCount;

  private boolean ddWriteMode;

  private boolean runTimeStatisticsSetting ;

  private boolean statisticsTiming;

  //all the temporary tables declared for this connection

  private ArrayList allDeclaredGlobalTempTables;

  //The currentSavepointLevel is used to provide the rollback behavior of temporary tables.

  //At any point, this variable has the total number of savepoints defined for the transaction.

  private int currentSavepointLevel = 0;

  protected long  nextCursorId;

  protected int  nextSavepointId;

  private RunTimeStatistics runTimeStatisticsObject;

  private StringBuffer sb;

  private Database db;

  private final int instanceNumber;

  private String drdaID;

  private String dbname;

    private int identifierCasing = UNKNOWN_CASING;

   

  /**

  The transaction to use within this language connection context.  It may

  be more appropriate to have it in a separate context (LanguageTransactionContext?).

  REVISIT (nat): I shoehorned the transaction context that

  the language uses into this class.  The main purpose is so

  that the various language code can find out what its

  transaction is.

  **/

  protected TransactionController tran;

  /**

   * If non-null indicates that a nested user transaction is in progress.

   */

  protected TransactionController childTransaction;

 

  /**

   * queryNestingDepth is a counter used to keep track of how many calls

   * have been made to begin nested transactions. Only the first call

   * actually starts a Nested User Transaction with the store. Subsequent

   * calls simply increment this counter. commitNestedTransaction only

   * decrements the counter and when it drops to 0 actually commits the

   * nested user transaction.

   */

  protected int queryNestingDepth;

  protected DataValueFactory dataFactory;

  protected LanguageFactory langFactory;

  protected TypeCompilerFactory tcf;

  protected OptimizerFactory of;

  protected LanguageConnectionFactory connFactory;

 

  /*

   * A statement context is "pushed" and "popped" at the beginning and

     * end of every statement so that only that statement is cleaned up

     * on a Statement Exception.  As a performance optimization, we only push

     * the outermost statement context once, and never pop it.  Also, we

   * save off a 2nd StatementContext for speeding server side method

   * invocation, though we still push and pop it as needed.  All other

     * statement contexts will allocated and pushed and popped on demand.

     */

  private final StatementContext[] statementContexts = new StatementContext[2];

  private int     statementDepth;

  protected int    outermostTrigger = -1;

    protected Authorizer authorizer;

  protected String userName = null; //The name the user connects with.

                                    //May still be quoted.

 

  protected SchemaDescriptor  sd;

  // RESOLVE - How do we want to set the default.

    private int defaultIsolationLevel = ExecutionContext.READ_COMMITTED_ISOLATION_LEVEL;

  protected int isolationLevel = defaultIsolationLevel;

  private boolean isolationLevelExplicitlySet = false;

  // Isolation level can be changed using JDBC api Connection.setTransactionIsolation

  // or it can be changed using SQL "set current isolation = NEWLEVEL".

  //

  // In XA transactions, BrokeredConnection keeps isolation state information.

  // When isolation is changed in XA transaction using JDBC, that state gets

  // correctly set in BrokeredConnection.setTransactionIsolation method. But

  // when SQL is used to set the isolation level, the code path is different

  // and it does not go through BrokeredConnection's setTransactionIsolation

  // method and hence the state is not maintained correctly when coming through

  // SQL. To get around this, I am adding following flag which will get set

  // everytime the isolation level is set using JDBC or SQL. This flag will be

  // checked at global transaction start and end time. If the flag is set to true

  // then BrokeredConnection's isolation level state will be brought upto date

  // with Real Connection's isolation level and this flag will be set to false

  // after that.

  private boolean isolationLevelSetUsingSQLorJDBC = false;

  // isolation level to when preparing statements.

  // if unspecified, the statement won't be prepared with a specific

  // scan isolationlevel

  protected int prepareIsolationLevel = ExecutionContext.UNSPECIFIED_ISOLATION_LEVEL;

  // Whether or not to write executing statement info to db2j.log

  private boolean logStatementText;

  private boolean logQueryPlan;

  private HeaderPrintWriter istream;

  // this used to be computed in OptimizerFactoryContextImpl; i.e everytime a

  // connection was made. To keep the semantics same I'm putting it out here

  // instead of in the OptimizerFactory which is only initialized when the

  // database is booted.

  private int lockEscalationThreshold;

  private Vector stmtValidators;

  private Vector triggerExecutionContexts;

  private Vector triggerTables;

  protected AccessFactory af;

  // OptimizerTrace

  private boolean optimizerTrace;

  private boolean optimizerTraceHtml;

  private String lastOptimizerTraceOutput;

  private String optimizerTraceOutput;

  //// Support for AUTOINCREMENT

  /**

   * To support lastAutoincrementValue: This is a hashtable which maps

   * schemaName,tableName,columnName to a Long value.

   */

  private Hashtable autoincrementHT;

  /**

   * whether to allow updates or not.

   */

  private boolean autoincrementUpdate;

  private long identityVal;  //support IDENTITY_VAL_LOCAL function

  private boolean identityNotNull;  //frugal programmer

  // cache of ai being handled in memory (bulk insert + alter table).

  private Hashtable autoincrementCacheHashtable;

  // temp public

  public CacheManager statementCache;

  /*

     constructor

  */

  public GenericLanguageConnectionContext

  (

   ContextManager cm,

   TransactionController tranCtrl,

   LanguageFactory lf,

   LanguageConnectionFactory lcf,

   Database db,

   String userName,

   int instanceNumber,

   String drdaID,

   String dbname)

     throws StandardException

  {

    super(cm, org.apache.derby.iapi.reference.ContextId.LANG_CONNECTION);

    acts = new Vector();

    tran = tranCtrl;

    dataFactory = lcf.getDataValueFactory();

    tcf = lcf.getTypeCompilerFactory();

    of = lcf.getOptimizerFactory();

    langFactory =  lf;

    connFactory =  lcf;

        this.db = db;

    this.userName = userName;

    this.instanceNumber = instanceNumber;

    this.drdaID = drdaID;

    this.dbname = dbname;

    /* Find out whether or not to log info on executing statements to error log

     */

    String logStatementProperty = PropertyUtil.getServiceProperty(getTransactionCompile(),

          "derby.language.logStatementText");

    logStatementText = Boolean.valueOf(logStatementProperty).booleanValue();

    String logQueryPlanProperty = PropertyUtil.getServiceProperty(getTransactionCompile(),

          "derby.language.logQueryPlan");

    logQueryPlan = Boolean.valueOf(logQueryPlanProperty).booleanValue();

    setRunTimeStatisticsMode(logQueryPlan);

    lockEscalationThreshold =

      PropertyUtil.getServiceInt(tranCtrl,

                     Property.LOCKS_ESCALATION_THRESHOLD,

                     Property.MIN_LOCKS_ESCALATION_THRESHOLD,

                     Integer.MAX_VALUE,

                     Property.DEFAULT_LOCKS_ESCALATION_THRESHOLD);                              

    stmtValidators = new Vector();

    triggerExecutionContexts = new Vector();

    triggerTables = new Vector();

   

    af = lcf.getAccessFactory();

    statementCache = lcf.getStatementCache();

  }

  public void initialize(boolean sqlConnection) throws StandardException

  {

    //

    //Creating the authorizer authorizes the connection.

    authorizer = new GenericAuthorizer(IdUtil.getUserAuthorizationId(userName),this, sqlConnection);

    //we can ignore the following if this is a database connection

    //associated with internal thread such as logSniffer and StageTrunc

    if(!sqlConnection)

      return;

    /*

    ** Set the authorization id.  User shouldn't

    ** be null or else we are going to blow up trying

    ** to create a schema for this user.

    */

    if (SanityManager.DEBUG)

    {

      if (getAuthorizationId() == null)

      {

        SanityManager.THROWASSERT("User name is null," +

          " check the connection manager to make sure it is set" +

          " reasonably");

      }

    }

    setDefaultSchema(initDefaultSchemaDescriptor());

  }

  protected SchemaDescriptor initDefaultSchemaDescriptor()

    throws StandardException {

    /*

    ** - If the database supports schemas and a schema with the

    ** same name as the user's name exists (has been created using

    ** create schema already) the database will set the users

    ** default schema to the the schema with the same name as the

    ** user.

        ** - Else Set the default schema to APP.

        */

    // SchemaDescriptor sd;

    DataDictionary dd = getDataDictionary();

        String authorizationId = getAuthorizationId();

 

    if ( (sd = dd.getSchemaDescriptor(authorizationId, getTransactionCompile(), false)) == null )

    {

      sd = new SchemaDescriptor(dd, authorizationId, authorizationId, (UUID) null, false);

    }

    return sd;

  }

  //

  // LanguageConnectionContext interface

  //

  /**

   * @see LanguageConnectionContext#getLogStatementText

   */

  public boolean getLogStatementText()

  {

    return logStatementText;

  }

  /**

   * @see LanguageConnectionContext#setLogStatementText

   */

  public void setLogStatementText(boolean logStatementText)

  {

    this.logStatementText = logStatementText;

  }

  /**

   * @see LanguageConnectionContext#getLogQueryPlan

   */

  public boolean getLogQueryPlan()

  {

    return logQueryPlan;

  }

  /**

   * @see LanguageConnectionContext#usesSqlAuthorization

   */

  public boolean usesSqlAuthorization()

  {

    return getDataDictionary().usesSqlAuthorization();

  }

  /**

   * get the lock escalation threshold.

   */

  public int getLockEscalationThreshold()

  {

    return lockEscalationThreshold;

  }

  /*

    The methods that follow are for consistency checking purposes

   */

  public int getCacheSize() {

    if (statementCache != null)

      return statementCache.getNumberInUse();

    else

      return 0;

  }

  /**

   * Add the activation to those known about by this connection.

   */

  public void addActivation(Activation a)

    throws StandardException {

    acts.addElement(a);

    // DERBY-418. Activations which are marked unused,

    // are closed here. Activations Vector is iterated

    // to identify and close unused activations, only if

    // unusedActs flag is set to true and if the total

    // size exceeds 20.

    if( (unusedActs) && (acts.size() > 20) ) {

      unusedActs = false;

      for (int i = acts.size() - 1; i >= 0; i--) {

        // it maybe the case that a Activation's reset() ends up

        // closing one or more activation leaving our index beyond

        // the end of the array

        if (i >= acts.size())

          continue;

        Activation a1 = (Activation) acts.elementAt(i);

        if (!a1.isInUse()) {

          a1.close();

        }

      }

    }

    if (SanityManager.DEBUG) {

      if (SanityManager.DEBUG_ON("memoryLeakTrace")) {

        if (acts.size() > 20)

          System.out.println("memoryLeakTrace:GenericLanguageContext:activations " + acts.size());

      }

    }

  }

  /**

   * Make a note that some activations are marked unused

   */

  public void notifyUnusedActivation() {

      unusedActs = true;

  }

  /**

   * @see LanguageConnectionContext#checkIfAnyDeclaredGlobalTempTablesForThisConnection

   */

  public boolean checkIfAnyDeclaredGlobalTempTablesForThisConnection() {

    return (allDeclaredGlobalTempTables == null ? false : true);

  }

  /**

   * @see LanguageConnectionContext#addDeclaredGlobalTempTable

   */

  public void addDeclaredGlobalTempTable(TableDescriptor td)

    throws StandardException {

    if (findDeclaredGlobalTempTable(td.getName()) != null) //if table already declared, throw an exception

    {

      throw

        StandardException.newException(

                         SQLState.LANG_OBJECT_ALREADY_EXISTS_IN_OBJECT,

                         "Declared global temporary table",

                         td.getName(),

                         "Schema",

                         SchemaDescriptor.STD_DECLARED_GLOBAL_TEMPORARY_TABLES_SCHEMA_NAME);

    }

    //save all the information about temp table in this special class

    TempTableInfo tempTableInfo = new TempTableInfo(td, currentSavepointLevel);

    if (allDeclaredGlobalTempTables == null)

      allDeclaredGlobalTempTables = new ArrayList();

    allDeclaredGlobalTempTables.add(tempTableInfo);

  }

  /**

   * @see LanguageConnectionContext#dropDeclaredGlobalTempTable

   */

  public boolean dropDeclaredGlobalTempTable(String tableName) {

    TempTableInfo tempTableInfo = findDeclaredGlobalTempTable(tableName);

    if (tempTableInfo != null)

    {

      if (SanityManager.DEBUG)

        if (tempTableInfo.getDeclaredInSavepointLevel() > currentSavepointLevel)

          SanityManager.THROWASSERT("declared in savepoint level can not be higher than the current savepoint level");

      //following checks if the table was declared in the current unit of work.

      if (tempTableInfo.getDeclaredInSavepointLevel() == currentSavepointLevel)

      {

        //since the table was declared in this unit of work,

        //the drop table method should remove it from the valid list of temp table for this unit of work

        allDeclaredGlobalTempTables.remove(allDeclaredGlobalTempTables.indexOf(tempTableInfo));

        if (allDeclaredGlobalTempTables.size() == 0)

          allDeclaredGlobalTempTables = null;

      }

      else

      {

        //since the table was not declared in this unit of work, the drop table method will just mark the table as dropped

        //in the current unit of work. This information will be used at rollback time.

        tempTableInfo.setDroppedInSavepointLevel(currentSavepointLevel);

      }

      return true;

    } else

      return false;

  }

  /**

   * After a release of a savepoint, we need to go through our temp tables list. If there are tables with their declare or drop

   * or modified in savepoint levels set to savepoint levels higher than the current savepoint level, then we should change them

   * to the current savepoint level

   */

  private void tempTablesReleaseSavepointLevels() {

    //unlike rollback, here we check for dropped in / declared in / modified in savepoint levels > current savepoint level only.

    //This is because the temp tables with their savepoint levels same as currentSavepointLevel have correct value assigned to them and

    //do not need to be changed and hence no need to check for >=

    for (int i = 0; i < allDeclaredGlobalTempTables.size(); i++) {

      TempTableInfo tempTableInfo = (TempTableInfo)allDeclaredGlobalTempTables.get(i);

      if (tempTableInfo.getDroppedInSavepointLevel() > currentSavepointLevel)

        tempTableInfo.setDroppedInSavepointLevel(currentSavepointLevel);

      if (tempTableInfo.getDeclaredInSavepointLevel() > currentSavepointLevel)

        tempTableInfo.setDeclaredInSavepointLevel(currentSavepointLevel);

      if (tempTableInfo.getModifiedInSavepointLevel() > currentSavepointLevel)

        tempTableInfo.setModifiedInSavepointLevel(currentSavepointLevel);

    }

  }

  /**

   * do the necessary work at commit time for temporary tables

   * 1)If a temporary table was marked as dropped in this transaction, then remove it from the list of temp tables for this connection

   * 2)If a temporary table was not dropped in this transaction, then mark it's declared savepoint level and modified savepoint level as -1

   */

  private void tempTablesAndCommit() {

    for (int i = allDeclaredGlobalTempTables.size()-1; i >= 0; i--) {

      TempTableInfo tempTableInfo = (TempTableInfo)allDeclaredGlobalTempTables.get(i);

      if (tempTableInfo.getDroppedInSavepointLevel() != -1)

      {

        //this means table was dropped in this unit of work and hence should be removed from valid list of temp tables

        allDeclaredGlobalTempTables.remove(i);

      } else //this table was not dropped in this unit of work, hence set its declaredInSavepointLevel as -1 and also mark it as not modified

      {

        tempTableInfo.setDeclaredInSavepointLevel(-1);

        tempTableInfo.setModifiedInSavepointLevel(-1);

      }

    }

  }

  /**

    Reset the connection before it is returned (indirectly) by

    a PooledConnection object. See EmbeddedConnection.

   */

  public void resetFromPool()

     throws StandardException

  {

    // Reset IDENTITY_VAL_LOCAL

    identityNotNull = false;

    // drop all temp tables.

    dropAllDeclaredGlobalTempTables();

  }

  /**

   * Drop all the declared global temporary tables associated with this connection. This gets called

   * when a getConnection() is done on a PooledConnection. This will ensure all the temporary tables

   * declared on earlier connection handle associated with this physical database connection are dropped

   * before a new connection handle is issued on that same physical database connection.

   */

  private void dropAllDeclaredGlobalTempTables() throws StandardException {