GenericLanguageConnectionContext

Documentation of 'org.apache.derby.impl.sql.conn.GenericLanguageConnectionContext' Java class GenericLanguageConnectionContext

Skip navigation links

All Classes

Summary:
Nested |
Field |
Constr |
Method

Detail:
Field |
Constr |
Method

java.lang.Object
- org.apache.derby.iapi.services.context.ContextImpl
- - org.apache.derby.impl.sql.conn.GenericLanguageConnectionContext

All Implemented Interfaces:

Context, LanguageConnectionContext
```
public class GenericLanguageConnectionContext
extends ContextImpl
implements LanguageConnectionContext
```
LanguageConnectionContext keeps the pool of prepared statements, activations, and cursors in use by the current connection.
The generic impl does not provide statement caching.

Field Summary
- Fields inherited from interface org.apache.derby.iapi.sql.conn.LanguageConnectionContext
  ANSI_CASING, ANTI_ANSI_CASING, CONTEXT_ID, dbnameStr, drdaStr, lccStr, MULTI_TRANSACTION_LOCK, NO_SCHEMAS, OUTERMOST_STATEMENT, SINGLE_TRANSACTION_LOCK, SQL92_SCHEMAS, UNKNOWN_CASING, USER_NAME_SCHEMA, xidStr

Constructor Summary

Constructors
Constructor and Description
`GenericLanguageConnectionContext(ContextManager cm, TransactionController tranCtrl, LanguageFactory lf, LanguageConnectionFactory lcf, Database db, java.lang.String userName, int instanceNumber, java.lang.String drdaID, java.lang.String dbname)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addActivation(Activation a)` Add the activation to those known about by this connection.
`void`	`addDeclaredGlobalTempTable(TableDescriptor td)` Add the declared global temporary table to the list of temporary tables known by this connection.
`java.lang.StringBuffer`	`appendErrorInfo()`
`void`	`autoincrementCreateCounter(java.lang.String s, java.lang.String t, java.lang.String c, java.lang.Long initialValue, long increment, int position)` Create an autoincrement counter to be used on behalf of a SQL-J statement.
`void`	`autoincrementFlushCache(UUID tableUUID)` Flush the cache of autoincrement values being kept by the lcc.
`void`	`beginNestedTransaction(boolean readOnly)` Start a Nested User Transaction (NUT) with the store.
`boolean`	`checkIfAnyDeclaredGlobalTempTablesForThisConnection()` Check if there are any global temporary tables declared for this connection.
`void`	`checkIntegrity()` Check that deferred constraints are valid, if not roll back the transaction.
`void`	`cleanupOnError(java.lang.Throwable error)` If worse than a transaction error, everything goes; we rely on other contexts to kill the context manager for this session.
`void`	`closeUnusedActivations()` Close any unused activations in this connection context.
`void`	`commitNestedTransaction()` commit a nested transaction.
`void`	`copyHashtableToAIHT(java.util.Map<java.lang.String,java.lang.Long> from)` Copies an existing autoincrement mapping into autoincrementHT, the cache of autoincrement values kept in the languageconnectioncontext.
`SQLSessionContext`	`createSQLSessionContext()` Create a fresh SQLSessionContext for this connection.
`boolean`	`dataDictionaryInWriteMode()` Return true if the data dictionary is in write mode (that is, this context was informed that is is in write mode by the method call setDataDictionaryWriteMode().
`int`	`decrementBindCount()` Decrement the DataDictionary bind count.
`boolean`	`dropDeclaredGlobalTempTable(java.lang.String tableName)` Drop (mark the declared global temporary table for dropping) from the list of temporary tables known by this connection.
`int`	`getActivationCount()` Return the number of activations known for this connection.
`ASTVisitor`	`getASTVisitor()` Get the Visitor which should walk the AST.
`Authorizer`	`getAuthorizer()` Get an Authorizer for this connection.
`boolean`	`getAutoincrementUpdate()` Returns the current value of autoincrementUpdate.
`int`	`getBindCount()` Get the DataDictionary bind count.
`int`	`getCurrentIsolationLevel()` Get the current isolation level.
`java.lang.String`	`getCurrentIsolationLevelStr()` Get the current isolation level in DB2 format.
`java.lang.String`	`getCurrentRoleId(Activation a)` Get the current role authorization identifier of the dynamic call context associated with this activation.
`java.lang.String`	`getCurrentRoleIdDelimited(Activation a)` Get the current role authorization identifier in external delimited form (not case normal form) of the dynamic call context associated with this activation.
`java.lang.String`	`getCurrentSchemaName()` Get the current schema name (at compile-time, see explanations for getDefaultSchema overloads).
`java.lang.String`	`getCurrentSchemaName(Activation a)` Get the current schema name (at execution time, see explanations for getDefaultSchema overloads); This version is used by CURRENT SCHEMA.
`SQLSessionContext`	`getCurrentSQLSessionContext(Activation activation)` Return the current SQL session context of the activation
`java.lang.String`	`getCurrentUserId(Activation a)` Get the Authorization Id of the current user
`Database`	`getDatabase()` Returns the Database of this connection.
`DataDictionary`	`getDataDictionary()` Get the data dictionary
`DataValueFactory`	`getDataValueFactory()` Get the data value factory to use with this language connection context.
`java.lang.String`	`getDbname()` Get the database name of this LCC.
`SchemaDescriptor`	`getDefaultSchema()` Get the default schema (used at compile-time when no activation is yet available, cf.
`SchemaDescriptor`	`getDefaultSchema(Activation a)` Get the default schema (used at execution time).
`java.util.HashMap<UUID,DeferredConstraintsMemory.ValidationInfo>`	`getDeferredHashTables()` Get the set of disk backed hash tables containing any index rows saved for deferred unique/PK constraints in this transaction, keyed by the conglomerate id, or rows saved containing row locations violating rows for deferred check constraints.
`java.lang.String`	`getDrdaID()` Get the DRDA ID of this LCC.
`java.lang.Long`	`getIdentityValue()` Get the identity column value most recently generated.
`int`	`getInstanceNumber()` Get the instance number of this LCC.
`StandardException`	`getInterruptedException()` Get exception created when we detected interruped status flag.
`LanguageConnectionFactory`	`getLanguageConnectionFactory()` Get the language connection factory to use with this language connection context.
`LanguageFactory`	`getLanguageFactory()` Get the language factory to use with this language connection context.
`Activation`	`getLastActivation()` Return the last activation added This is used to find the drop activation in dropViewCascade so we can add warning messages to the activation
`java.lang.Object`	`getLastQueryTree()` Debug method for retrieving the last query tree.
`int`	`getLockEscalationThreshold()` get the lock escalation threshold.
`boolean`	`getLogQueryPlan()` Get value of logQueryPlan.
`boolean`	`getLogStatementText()` Get value of logStatementText.
`OptimizerFactory`	`getOptimizerFactory()` get the optimizer factory to use with this language connection context.
`OptTrace`	`getOptimizerTracer()` Get the optimizer tracer (could be null if we aren't tracing the optimizer).
`int`	`getPrepareIsolationLevel()` Get the prepare isolation level.
`java.util.Map<java.lang.Object,java.lang.Object>`	`getPrintedObjectsMap()` Return a map of AST nodes that have already been printed during a compiler phase, so as to be able to avoid printing a node more than once.
`FormatableBitSet`	`getReferencedColumnMap(TableDescriptor td)` Get the referenced column map for a table
`boolean`	`getRunTimeStatisticsMode()` Get the RUNTIMESTATISTICS mode.
`RunTimeStatistics`	`getRunTimeStatisticsObject()` Get the RUNTIMESTATISTICS object.
`java.lang.String`	`getSessionUserId()` Get the session user
`StatementContext`	`getStatementContext()` Get the current StatementContext.
`int`	`getStatementDepth()` Reports how many statement levels deep we are.
`boolean`	`getStatisticsTiming()` Get the STATISTICS TIMING mode.
`TableDescriptor`	`getTableDescriptorForDeclaredGlobalTempTable(java.lang.String tableName)` Get table descriptor for the declared global temporary table from the list of temporary tables known by this connection.
`SQLSessionContext`	`getTopLevelSQLSessionContext()` Get the value of top level session context of the top level connection.
`TransactionController`	`getTransactionCompile()` Get the transaction controller to use at compile time with this language connection context.
`TransactionController`	`getTransactionExecute()` Get the transaction controller to use with this language connection context during execute time.
`TriggerExecutionContext`	`getTriggerExecutionContext()` Get the topmost tec.
`TableDescriptor`	`getTriggerTable()` Get the topmost trigger table descriptor
`java.lang.String`	`getUniqueCursorName()` Get a connection unique system generated name for a cursor.
`int`	`getUniqueSavepointID()` Get a connection unique system generated id for an unnamed savepoint.
`java.lang.String`	`getUniqueSavepointName()` Get a connection unique system generated name for an unnamed savepoint.
`boolean`	`getXplainOnlyMode()` gets the current set XplainOnlyMode
`java.lang.String`	`getXplainSchema()` gets the current set XplainSchema
`java.lang.Object`	`getXplainStatement(java.lang.Object key)`
`int`	`incrementBindCount()` Increment the DataDictionary bind count.
`void`	`initialize()` Initialize.
`void`	`internalCommit(boolean commitStore)` Do a commit as appropriate for an internally generated commit (e.g.
`void`	`internalCommitNoSync(int commitflag)` Commit the language transaction by doing a commitNoSync() on the store's TransactionController.
`void`	`internalRollback()` Do a rollback as appropriate for an internally generated rollback (e.g.
`void`	`internalRollbackToSavepoint(java.lang.String savepointName, boolean refreshStyle, java.lang.Object kindOfSavepoint)` Let the context deal with a rollback to savepoint
`boolean`	`isEffectivelyDeferred(SQLSessionContext sc, UUID constraintId)` Determines if a check or foreign key constraint has deferred mode.
`boolean`	`isInitialDefaultSchema(java.lang.String schemaName)` Return true if this schema name is the initial default schema for the current session.
`boolean`	`isIsolationLevelSetUsingSQLorJDBC()` Returns true if isolation level has been set using JDBC/SQL.
`boolean`	`isLastHandler(int severity)` Return whether or not this context is the "last" handler for a the specified severity level.
`boolean`	`isReadOnly()` Get the readOnly status for the current connection.
`boolean`	`isTransactionPristine()` Reports whether there is any outstanding work in the transaction.
`void`	`languageSetSavePoint(java.lang.String savepointName, java.lang.Object kindOfSavepoint)` Sets a savepoint.
`java.lang.Long`	`lastAutoincrementValue(java.lang.String schemaName, java.lang.String tableName, java.lang.String columnName)` lastAutoincrementValue searches for the last autoincrement value inserted into a column specified by the user.
`CursorActivation`	`lookupCursorActivation(java.lang.String cursorName)` See if a given cursor is available for use.
`PreparedStatement`	`lookupStatement(GenericStatement statement)` See if a given statement has already been compiled for this user, and if so use its prepared statement.
`void`	`markTempTableAsModifiedInUnitOfWork(java.lang.String tableName)` Mark the passed temporary table as modified in the current unit of work.
`long`	`nextAutoincrementValue(java.lang.String schemaName, java.lang.String tableName, java.lang.String columnName)` returns the next value to be inserted into an autoincrement col.
`void`	`notifyUnusedActivation()` Make a note that some activations are marked unused
`boolean`	`optimizerTracingIsOn()` Get whether or not optimizer trace is on.
`void`	`popCompilerContext(CompilerContext cc)` Pop a CompilerContext off the context stack.
`void`	`popExecutionStmtValidator(ExecutionStmtValidator validator)` Remove the validator.
`void`	`popNestedSessionContext(Activation a)` If returning from a routine that can execute SQL, perform any actions needed when popping the SQL session context.
`void`	`popStatementContext(StatementContext statementContext, java.lang.Throwable error)` Pop a StatementContext of the context stack.
`void`	`popTriggerExecutionContext(TriggerExecutionContext tec)` Remove the tec.
`void`	`popTriggerTable(TableDescriptor td)` Remove the trigger table descriptor.
`PreparedStatement`	`prepareInternalStatement(SchemaDescriptor compilationSchema, java.lang.String sqlText, boolean isForReadOnly, boolean forMetaData)` Return a PreparedStatement object for the query.
`PreparedStatement`	`prepareInternalStatement(java.lang.String sqlText)` Return a PreparedStatement object for the query.
`CompilerContext`	`pushCompilerContext()` Push a CompilerContext on the context stack with the current default schema as the default schema which we compile against.
`CompilerContext`	`pushCompilerContext(SchemaDescriptor sd)` Push a CompilerContext on the context stack with the passed in schema sd as the default schema we compile against.
`void`	`pushExecutionStmtValidator(ExecutionStmtValidator validator)` Push a new execution statement validator.
`void`	`pushNestedSessionContext(Activation a, boolean definersRights, java.lang.String definer)` Create a new SQL session context for the current activation on the basis of the existing SQL session context.
`StatementContext`	`pushStatementContext(boolean isAtomic, boolean isForReadOnly, java.lang.String stmtText, ParameterValueSet pvs, boolean rollbackParentContext, long timeoutMillis)` Push a StatementContext on the context stack.
`void`	`pushTriggerExecutionContext(TriggerExecutionContext tec)` Push a new trigger execution context.
`void`	`pushTriggerTable(TableDescriptor td)` Set the trigger table descriptor.
`void`	`releaseSavePoint(java.lang.String savepointName, java.lang.Object kindOfSavepoint)` Let the context deal with a release of a savepoint
`void`	`removeActivation(Activation a)` Remove the activation to those known about by this connection.
`void`	`removeStatement(GenericStatement statement)` This method will remove a statement from the statement cache.
`void`	`resetFromPool()` Reset the connection before it is returned (indirectly) by a PooledConnection object.
`void`	`resetIsolationLevelFlagUsedForSQLandJDBC()` Reset the isolation level flag used to keep correct isolation level state in BrokeredConnection.
`void`	`resetSchemaUsages(Activation activation, java.lang.String schemaName)` Reset any occurence of schemaName as current default schema in the SQLSessionContext stack to the initial default, because schemaName is no longer a valid schema.
`boolean`	`roleIsSettable(Activation a, java.lang.String role)` Checks whether the given role can be legally set for the current user.
`void`	`setASTVisitor(ASTVisitor visitor)` Set a Visitor which walks the AST at various stages.
`void`	`setAutoincrementUpdate(boolean flag)` Sets autoincrementUpdate-- this variable allows updates to autoincrement columns if it is set to true.
`void`	`setConstraintDeferred(Activation a, ConstraintDescriptor cd, boolean deferred)` Set the constraint mode to deferred for the specified constraint.
`void`	`setCurrentRole(Activation a, java.lang.String role)` Set the current role
`void`	`setDataDictionaryWriteMode()` Remember that the DataDictionary is in write mode, so we can take it out of write mode at the end of the transaction.
`void`	`setDefaultSchema(Activation a, SchemaDescriptor sd)` Set the default schema (at execution time, see explanations for getDefaultSchema overloads); This version is used by SET SCHEMA.
`void`	`setDefaultSchema(SchemaDescriptor sd)` Set the default schema (at compile-time, see explanations for getDefaultSchema overloads).
`void`	`setDeferredAll(Activation a, boolean deferred)` Set the constraint mode of all deferrable constraints to the value of `deferred`.
`void`	`setDrdaID(java.lang.String drdaID)` Set the DRDA ID of this LCC.
`void`	`setIdentityValue(long val)` Set the field of most recently generated identity column value.
`void`	`setInterruptedException(StandardException e)` Set the exception created and associated with the detected interruped status flag.
`void`	`setIsolationLevel(int isolationLevel)` Set current isolation level.
`void`	`setLastQueryTree(java.lang.Object queryTree)` Debug method for remembering the last query tree.
`void`	`setLogStatementText(boolean logStatementText)` Set value of logStatementText (Whether or not to write info on currently executing statement to error log.)
`void`	`setOptimizerTracer(OptTrace tracer)` Install an optimizer tracer (to enable tracing) or uninstall the current optimizer tracer (to disable tracing).
`void`	`setPrepareIsolationLevel(int level)`
`void`	`setReadOnly(boolean on)` Set the readOnly status for the current connection.
`void`	`setReferencedColumnMap(TableDescriptor td, FormatableBitSet map)` Set the referenced column map for a table
`void`	`setRunTimeStatisticsMode(boolean onOrOff)` Turn RUNTIMESTATISTICS on or off.
`void`	`setRunTimeStatisticsObject(RunTimeStatistics runTimeStatisticsObject)` Set the RUNTIMESTATISTICS object.
`void`	`setStatisticsTiming(boolean onOrOff)` Turn STATISTICS TIMING on or off.
`void`	`setupSubStatementSessionContext(Activation a)` Used when a statement as part of its operation executes an other statement.
`void`	`setXplainOnlyMode(boolean onOrOff)` sets the XplainOnlyMode.
`void`	`setXplainSchema(java.lang.String s)` sets the XplainSchema
`void`	`setXplainStatement(java.lang.Object key, java.lang.Object stmt)`
`void`	`userCommit()` Do a commmit as is appropriate for a user requested commit (e.g.
`void`	`userRollback()` Do a rollback as is appropriate for a user requested rollback (e.g.
`boolean`	`usesSqlAuthorization()` Check if in SQL standard mode, with support for Grant & Revoke
`void`	`validateStmtExecution(ConstantAction constantAction)` Validate a statement.
`boolean`	`verifyAllHeldResultSetsAreClosed()` Verify that there are no activations with open held result sets.
`boolean`	`verifyNoOpenResultSets(PreparedStatement pStmt, Provider provider, int action)` Verify that there are no activations with open result sets on the specified prepared statement.
`void`	`xaCommit(boolean onePhase)` Same as userCommit except commit a distributed transaction.
`void`	`xaRollback()` Same as userRollback() except rolls back a distrubuted transaction.

Methods inherited from class org.apache.derby.iapi.services.context.ContextImpl
getContextManager, getIdName, popMe, pushMe

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

Methods inherited from interface org.apache.derby.iapi.services.context.Context
getContextManager, getIdName, popMe, pushMe

- Constructor Detail
  - GenericLanguageConnectionContext
```
public GenericLanguageConnectionContext(ContextManager cm,
                                        TransactionController tranCtrl,
                                        LanguageFactory lf,
                                        LanguageConnectionFactory lcf,
                                        Database db,
                                        java.lang.String userName,
                                        int instanceNumber,
                                        java.lang.String drdaID,
                                        java.lang.String dbname)
                                 throws StandardException
```
    Throws:
    
    StandardException
- Method Detail
  - initialize
```
public void initialize()
                throws StandardException
```
    Description copied from interface: LanguageConnectionContext
    
    Initialize. For use after pushing the contexts that initialization needs.
    
    Specified by:
    
    initialize in interface LanguageConnectionContext
    
    Throws:
    
    StandardException - thrown if something goes wrong
  - getLogStatementText
```
public boolean getLogStatementText()
```
    Description copied from interface: LanguageConnectionContext
    
    Get value of logStatementText. (Whether or not to write info on currently executing statement to error log.)
    
    Specified by:
    
    getLogStatementText in interface LanguageConnectionContext
    
    Returns:
    
    value of logStatementText
    
    See Also:
    
    LanguageConnectionContext.getLogStatementText()
  - setLogStatementText
```
public void setLogStatementText(boolean logStatementText)
```
    Description copied from interface: LanguageConnectionContext
    
    Set value of logStatementText (Whether or not to write info on currently executing statement to error log.)
    
    Specified by:
    
    setLogStatementText in interface LanguageConnectionContext
    
    Parameters:
    
    logStatementText - Whether or not logStatementText property is set.
    
    See Also:
    
    LanguageConnectionContext.setLogStatementText(boolean)
  - getLogQueryPlan
```
public boolean getLogQueryPlan()
```
    Description copied from interface: LanguageConnectionContext
    
    Get value of logQueryPlan. (Whether or not to write query plan info on currently executing statement to error log.)
    
    Specified by:
    
    getLogQueryPlan in interface LanguageConnectionContext
    
    Returns:
    
    value of logQueryPlan
    
    See Also:
    
    LanguageConnectionContext.getLogQueryPlan()
  - usesSqlAuthorization
```
public boolean usesSqlAuthorization()
```
    Description copied from interface: LanguageConnectionContext
    
    Check if in SQL standard mode, with support for Grant & Revoke
    
    Specified by:
    
    usesSqlAuthorization in interface LanguageConnectionContext
    
    Returns:
    
    True if SQL standard permissions are being used
    
    See Also:
    
    LanguageConnectionContext.usesSqlAuthorization()
  - getLockEscalationThreshold
```
public int getLockEscalationThreshold()
```
    get the lock escalation threshold.
    
    Specified by:
    
    getLockEscalationThreshold in interface LanguageConnectionContext
  - addActivation
```
public void addActivation(Activation a)
                   throws StandardException
```
    Add the activation to those known about by this connection.
    
    Specified by:
    
    addActivation in interface LanguageConnectionContext
    
    Throws:
    
    StandardException
  - closeUnusedActivations
```
public void closeUnusedActivations()
                            throws StandardException
```
    Description copied from interface: LanguageConnectionContext
    
    Close any unused activations in this connection context.
    
    Specified by:
    
    closeUnusedActivations in interface LanguageConnectionContext
    
    Throws:
    
    StandardException
  - notifyUnusedActivation
```
public void notifyUnusedActivation()
```
    Make a note that some activations are marked unused
    
    Specified by:
    
    notifyUnusedActivation in interface LanguageConnectionContext
  - checkIfAnyDeclaredGlobalTempTablesForThisConnection
```
public boolean checkIfAnyDeclaredGlobalTempTablesForThisConnection()
```
    Description copied from interface: LanguageConnectionContext
    
    Check if there are any global temporary tables declared for this connection.
    
    Specified by:
    
    checkIfAnyDeclaredGlobalTempTablesForThisConnection in interface LanguageConnectionContext
    
    Returns:
    
    true if there are declared temp tables for this connectoin else false
    
    See Also:
    
    LanguageConnectionContext.checkIfAnyDeclaredGlobalTempTablesForThisConnection()
  - addDeclaredGlobalTempTable
```
public void addDeclaredGlobalTempTable(TableDescriptor td)
                                throws StandardException
```
    Description copied from interface: LanguageConnectionContext
    
    Add the declared global temporary table to the list of temporary tables known by this connection.
    
    Specified by:
    
    addDeclaredGlobalTempTable in interface LanguageConnectionContext
    
    Parameters:
    
    td - Corresponding to the temporary table
    
    Throws:
    
    StandardException
    
    See Also:
    
    LanguageConnectionContext.addDeclaredGlobalTempTable(org.apache.derby.iapi.sql.dictionary.TableDescriptor)
  - dropDeclaredGlobalTempTable
```
public boolean dropDeclaredGlobalTempTable(java.lang.String tableName)
```
    Description copied from interface: LanguageConnectionContext
    
    Drop (mark the declared global temporary table for dropping) from the list of temporary tables known by this connection.
    
    Specified by:
    
    dropDeclaredGlobalTempTable in interface LanguageConnectionContext
    
    Parameters:
    
    tableName - look for this table name in the saved list and drop it if found
    
    Returns:
    
    true if dropped the temporary table. False if no such temporary table exists.
    
    See Also:
    
    LanguageConnectionContext.dropDeclaredGlobalTempTable(java.lang.String)
  - resetFromPool
```
public void resetFromPool()
                   throws StandardException
```
    Reset the connection before it is returned (indirectly) by a PooledConnection object. See EmbeddedConnection.
    
    Specified by:
    
    resetFromPool in interface LanguageConnectionContext
    
    Throws:
    
    StandardException
  - setLastQueryTree
```
public void setLastQueryTree(java.lang.Object queryTree)
```
    Description copied from interface: LanguageConnectionContext
    
    Debug method for remembering the last query tree.
    
    Specified by:
    
    setLastQueryTree in interface LanguageConnectionContext
  - getLastQueryTree
```
public java.lang.Object getLastQueryTree()
```
    Description copied from interface: LanguageConnectionContext
    
    Debug method for retrieving the last query tree.
    
    Specified by:
    
    getLastQueryTree in interface LanguageConnectionContext
  - getTableDescriptorForDeclaredGlobalTempTable
```
public TableDescriptor getTableDescriptorForDeclaredGlobalTempTable(java.lang.String tableName)
```
    Description copied from interface: LanguageConnectionContext
    
    Get table descriptor for the declared global temporary table from the list of temporary tables known by this connection.
    
    Specified by:
    
    getTableDescriptorForDeclaredGlobalTempTable in interface LanguageConnectionContext
    
    Parameters:
    
    tableName - Get table descriptor for the passed table name
    
    Returns:
    
    TableDescriptor if found the temporary table. Else return null
    
    See Also:
    
    LanguageConnectionContext.getTableDescriptorForDeclaredGlobalTempTable(java.lang.String)
  - markTempTableAsModifiedInUnitOfWork
```
public void markTempTableAsModifiedInUnitOfWork(java.lang.String tableName)
```
    Description copied from interface: LanguageConnectionContext
    
    Mark the passed temporary table as modified in the current unit of work. That information will be used at rollback time The compile phase will generate code to call this method if the DML is on a temporary table
    
    Specified by:
    
    markTempTableAsModifiedInUnitOfWork in interface LanguageConnectionContext
    
    Parameters:
    
    tableName - Mark the passed temporary table name as modified
    
    See Also:
    
    LanguageConnectionContext.markTempTableAsModifiedInUnitOfWork(java.lang.String)
  - prepareInternalStatement
```
public PreparedStatement prepareInternalStatement(SchemaDescriptor compilationSchema,
                                                  java.lang.String sqlText,
                                                  boolean isForReadOnly,
                                                  boolean forMetaData)
                                           throws StandardException
```
    Description copied from interface: LanguageConnectionContext
    
    Return a PreparedStatement object for the query. This method first tries to locate the PreparedStatement object from a statement cache. If the statement is not found in the cache, the query will be compiled and put into the cache.
    
    Specified by:
    
    prepareInternalStatement in interface LanguageConnectionContext
    
    Parameters:
    
    compilationSchema - schema
    
    sqlText - sql query string
    
    isForReadOnly - read only status for resultset. Set to true if the concurrency mode for the resultset is CONCUR_READ_ONLY
    
    forMetaData - If true, then this query is allowed to use internal sql syntax. One instance where this will be true is if a metadata query is getting executed.
    
    Throws:
    
    StandardException
    
    See Also:
    
    LanguageConnectionContext.prepareInternalStatement(org.apache.derby.iapi.sql.dictionary.SchemaDescriptor, java.lang.String, boolean, boolean)
  - prepareInternalStatement
```
public PreparedStatement prepareInternalStatement(java.lang.String sqlText)
                                           throws StandardException
```
    Description copied from interface: LanguageConnectionContext
    
    Return a PreparedStatement object for the query. This method first tries to locate the PreparedStatement object from a statement cache. If the statement is not found in the cache, the query will be compiled and put into the cache. The schema used when compiling the statement is the same schema as returned by getDefaultSchema(). For internal statements, the read only status is set to true. Calling this method is equivalent to calling prepareExternalStatement(lcc.getDefaultSchema(), sqlText, true);
    
    Specified by:
    
    prepareInternalStatement in interface LanguageConnectionContext
    
    Parameters:
    
    sqlText - sql query string
    
    Throws:
    
    StandardException
    
    See Also:
    
    LanguageConnectionContext.prepareInternalStatement(org.apache.derby.iapi.sql.dictionary.SchemaDescriptor, java.lang.String, boolean, boolean)
  - removeActivation
```
public void removeActivation(Activation a)
```
    Remove the activation to those known about by this connection.
    
    Specified by:
    
    removeActivation in interface LanguageConnectionContext
  - getActivationCount
```
public int getActivationCount()
```
    Return the number of activations known for this connection. Note that some of these activations may not be in use (when a prepared statement is finalized, its activations are marked as unused and later closed and removed on the next commit/rollback).
    
    Specified by:
    
    getActivationCount in interface LanguageConnectionContext
  - lookupCursorActivation
```
public CursorActivation lookupCursorActivation(java.lang.String cursorName)
```
    See if a given cursor is available for use. if so return its activation. Returns null if not found. For use in execution.
    
    Specified by:
    
    lookupCursorActivation in interface LanguageConnectionContext
    
    Returns:
    
    the activation for the given cursor, null if none was found.
  - removeStatement
```
public void removeStatement(GenericStatement statement)
                     throws StandardException
```
    This method will remove a statement from the statement cache. It should only be called if there is an exception preparing the statement. The caller must have set the flag preparedStmt.compilingStatement in the GenericStatement before calling this method in order to prevent race conditions when calling CacheManager.remove(Cacheable).
    
    Parameters:
    
    statement - Statement to remove
    
    Throws:
    
    StandardException - thrown if lookup goes wrong.
  - lookupStatement
```
public PreparedStatement lookupStatement(GenericStatement statement)
                                  throws StandardException
```
    See if a given statement has already been compiled for this user, and if so use its prepared statement. Returns null if not found.
    
    Returns:
    
    the prepared statement for the given string, null if none was found.
    
    Throws:
    
    StandardException - thrown if lookup goes wrong.
  - getUniqueCursorName
```
public java.lang.String getUniqueCursorName()
```
    Get a connection unique system generated name for a cursor.
    
    Specified by:
    
    getUniqueCursorName in interface LanguageConnectionContext
  - getUniqueSavepointName
```
public java.lang.String getUniqueSavepointName()
```
    Get a connection unique system generated name for an unnamed savepoint.
    
    Specified by:
    
    getUniqueSavepointName in interface LanguageConnectionContext
  - getUniqueSavepointID
```
public int getUniqueSavepointID()
```
    Get a connection unique system generated id for an unnamed savepoint.
    
    Specified by:
    
    getUniqueSavepointID in interface LanguageConnectionContext
  - internalCommit
```
public void internalCommit(boolean commitStore)
                    throws StandardException
```
    Do a commit as appropriate for an internally generated commit (e.g. as needed by sync, or autocommit).
    
    Specified by:
    
    internalCommit in interface LanguageConnectionContext
    
    Parameters:
    
    commitStore - true if we should commit the Store transaction
    
    Throws:
    
    StandardException - thrown on failure
  - userCommit
```
public void userCommit()
                throws StandardException
```
    Do a commmit as is appropriate for a user requested commit (e.g. a java.sql.Connection.commit() or a language 'COMMIT' statement. Does some extra checking to make sure that users aren't doing anything bad.
    
    Specified by:
    
    userCommit in interface LanguageConnectionContext
    
    Throws:
    
    StandardException - thrown on failure
  - internalCommitNoSync
```
public final void internalCommitNoSync(int commitflag)
                                throws StandardException
```
    Commit the language transaction by doing a commitNoSync() on the store's TransactionController.
    Do *NOT* tell the data dictionary that the transaction is finished. The reason is that this would allow other transactions to see comitted DDL that could be undone in the event of a system crash.
    
    Specified by:
    
    internalCommitNoSync in interface LanguageConnectionContext
    
    Parameters:
    
    commitflag - the flags to pass to commitNoSync in the store's TransactionController
    
    Throws:
    
    StandardException - thrown on failure
  - xaCommit
```
public final void xaCommit(boolean onePhase)
                    throws StandardException
```
    Same as userCommit except commit a distributed transaction. This commit always commit store and sync the commit.
    
    Specified by:
    
    xaCommit in interface LanguageConnectionContext
    
    Parameters:
    
    onePhase - if true, allow it to commit without first going thru a prepared state.
    
    Throws:
    
    StandardException - thrown if something goes wrong
  - internalRollback
```
public void internalRollback()
                      throws StandardException
```
    Do a rollback as appropriate for an internally generated rollback (e.g. as needed by sync, or autocommit). When a rollback happens, we close all open activations and invalidate their prepared statements. We then tell the cache to age out everything else, which effectively invalidates them. Thus, all prepared statements will be compiled anew on their 1st execution after a rollback.
    The invalidated statements can revalidate themselves without a full recompile if they verify their dependencies' providers still exist unchanged. REVISIT when invalidation types are created.
    REVISIT: this may need additional alterations when RELEASE SAVEPOINT/ROLLBACK TO SAVEPOINT show up.
    Also, tell the data dictionary that the transaction is finished, if necessary (that is, if the data dictionary was put into DDL mode in this transaction.
    
    Specified by:
    
    internalRollback in interface LanguageConnectionContext
    
    Throws:
    
    StandardException - thrown on failure
  - userRollback
```
public void userRollback()
                  throws StandardException
```
    Do a rollback as is appropriate for a user requested rollback (e.g. a java.sql.Connection.rollback() or a language 'ROLLBACk' statement. Does some extra checking to make sure that users aren't doing anything bad.
    
    Specified by:
    
    userRollback in interface LanguageConnectionContext
    
    Throws:
    
    StandardException - thrown on failure
  - xaRollback
```
public void xaRollback()
                throws StandardException
```
    Same as userRollback() except rolls back a distrubuted transaction.
    
    Specified by:
    
    xaRollback in interface LanguageConnectionContext
    
    Throws:
    
    StandardException - thrown if something goes wrong
  - internalRollbackToSavepoint
```
public void internalRollbackToSavepoint(java.lang.String savepointName,
                                        boolean refreshStyle,
                                        java.lang.Object kindOfSavepoint)
                                 throws StandardException
```
    Let the context deal with a rollback to savepoint
    
    Specified by:
    
    internalRollbackToSavepoint in interface LanguageConnectionContext
    
    Parameters:
    
    savepointName - Name of the savepoint that needs to be rolled back
    
    refreshStyle - boolean indicating whether or not the controller should close open conglomerates and scans. Also used to determine if language should close open activations.
    
    kindOfSavepoint - A NULL value means it is an internal savepoint (ie not a user defined savepoint) Non NULL value means it is a user defined savepoint which can be a SQL savepoint or a JDBC savepoint A String value for kindOfSavepoint would mean it is SQL savepoint A JDBC Savepoint object value for kindOfSavepoint would mean it is JDBC savepoint
    
    Throws:
    
    StandardException - thrown if something goes wrong
  - releaseSavePoint
```
public void releaseSavePoint(java.lang.String savepointName,
                             java.lang.Object kindOfSavepoint)
                      throws StandardException
```
    Let the context deal with a release of a savepoint
    
    Specified by:
    
    releaseSavePoint in interface LanguageConnectionContext
    
    Parameters:
    
    savepointName - Name of the savepoint that needs to be released
    
    kindOfSavepoint - A NULL value means it is an internal savepoint (ie not a user defined savepoint) Non NULL value means it is a user defined savepoint which can be a SQL savepoint or a JDBC savepoint A String value for kindOfSavepoint would mean it is SQL savepoint A JDBC Savepoint object value for kindOfSavepoint would mean it is JDBC savepoint
    
    Throws:
    
    StandardException - thrown if something goes wrong
  - languageSetSavePoint
```
public void languageSetSavePoint(java.lang.String savepointName,
                                 java.lang.Object kindOfSavepoint)
                          throws StandardException
```
    Sets a savepoint. Causes the Store to set a savepoint.
    
    Specified by:
    
    languageSetSavePoint in interface LanguageConnectionContext
    
    Parameters:
    
    savepointName - name of savepoint
    
    kindOfSavepoint - A NULL value means it is an internal savepoint (ie not a user defined savepoint) Non NULL value means it is a user defined savepoint which can be a SQL savepoint or a JDBC savepoint A String value for kindOfSavepoint would mean it is SQL savepoint A JDBC Savepoint object value for kindOfSavepoint would mean it is JDBC savepoint
    
    Throws:
    
    StandardException - thrown if something goes wrong
  - beginNestedTransaction
```
public void beginNestedTransaction(boolean readOnly)
                            throws StandardException
```
    Start a Nested User Transaction (NUT) with the store. If a NUT is already active simply increment a counter, queryNestingDepth, to keep track of how many times we have tried to start a NUT.
    
    Specified by:
    
    beginNestedTransaction in interface LanguageConnectionContext
    
    Parameters:
    
    readOnly - The nested transaction would be read only if param value true
    
    Throws:
    
    StandardException - on error.
    
    See Also:
    
    TransactionController.startNestedUserTransaction(boolean, boolean)
  - commitNestedTransaction
```
public void commitNestedTransaction()
                             throws StandardException
```
    Description copied from interface: LanguageConnectionContext
    
    commit a nested transaction. We do not provide a abortNestedTransaction. If a nested xaction is aborted, then this results in the parent xaction also being aborted. This is not what we need for releasing compile time locks or autoincrement-- hence we do not provide abortNestedTransaction.
    
    Specified by:
    
    commitNestedTransaction in interface LanguageConnectionContext
    
    Throws:
    
    StandardException - thrown on erro
    
    See Also:
    
    TransactionController.startNestedUserTransaction(boolean, boolean)
  - getTransactionCompile
```
public final TransactionController getTransactionCompile()
```
    Get the transaction controller to use at compile time with this language connection context. If a NUT is active then return NUT else return parent transaction.
    
    Specified by:
    
    getTransactionCompile in interface LanguageConnectionContext
  - getTransactionExecute
```
public TransactionController getTransactionExecute()
```
    Description copied from interface: LanguageConnectionContext
    
    Get the transaction controller to use with this language connection context during execute time.
    
    Specified by:
    
    getTransactionExecute in interface LanguageConnectionContext
  - getDataValueFactory
```
public DataValueFactory getDataValueFactory()
```
    Get the data value factory to use with this language connection context.
    
    Specified by:
    
    getDataValueFactory in interface LanguageConnectionContext
  - getLanguageFactory
```
public LanguageFactory getLanguageFactory()
```
    Get the language factory to use with this language connection context.
    
    Specified by:
    
    getLanguageFactory in interface LanguageConnectionContext
  - getOptimizerFactory
```
public OptimizerFactory getOptimizerFactory()
```
    Description copied from interface: LanguageConnectionContext
    
    get the optimizer factory to use with this language connection context.
    
    Specified by:
    
    getOptimizerFactory in interface LanguageConnectionContext
  - getLanguageConnectionFactory
```
public LanguageConnectionFactory getLanguageConnectionFactory()
```
    Get the language connection factory to use with this language connection context.
    
    Specified by:
    
    getLanguageConnectionFactory in interface LanguageConnectionContext
  - verifyAllHeldResultSetsAreClosed
```
public boolean verifyAllHeldResultSetsAreClosed()
                                         throws StandardException
```
    Verify that there are no activations with open held result sets.
    
    Specified by:
    
    verifyAllHeldResultSetsAreClosed in interface LanguageConnectionContext
    
    Returns:
    
    boolean Found no open (held) resultsets.
    
    Throws:
    
    StandardException - thrown on failure
  - verifyNoOpenResultSets
```
public boolean verifyNoOpenResultSets(PreparedStatement pStmt,
                                      Provider provider,
                                      int action)
                               throws StandardException
```
    Verify that there are no activations with open result sets on the specified prepared statement.
    
    Specified by:
    
    verifyNoOpenResultSets in interface LanguageConnectionContext
    
    Parameters:
    
    pStmt - The prepared Statement
    
    provider - The object precipitating a possible invalidation
    
    action - The action causing the possible invalidation
    
    Returns:
    
    Nothing.
    
    Throws:
    
    StandardException - thrown on failure
  - getSessionUserId
```
public java.lang.String getSessionUserId()
```
    Get the session user
    
    Specified by:
    
    getSessionUserId in interface LanguageConnectionContext
    
    Returns:
    
    String the authorization id of the session user.
  - getDefaultSchema
```
public SchemaDescriptor getDefaultSchema()
```
    Description copied from interface: LanguageConnectionContext
    
    Get the default schema (used at compile-time when no activation is yet available, cf. the activation argument overload version.
    
    Specified by:
    
    getDefaultSchema in interface LanguageConnectionContext
    
    Returns:
    
    SchemaDescriptor the default schema
    
    See Also:
    
    LanguageConnectionContext.getDefaultSchema()
  - getDefaultSchema
```
public SchemaDescriptor getDefaultSchema(Activation a)
```
    Description copied from interface: LanguageConnectionContext
    
    Get the default schema (used at execution time). At execution time, the current statement context is not always a reliable place to find the correct SQL session context, viz. when a dynamic result set referencing CURRENT SCHEMA is accessed after a called procedure has returned only the activation of the call is live and still holds the correct session context.
    
    Specified by:
    
    getDefaultSchema in interface LanguageConnectionContext
    
    Parameters:
    
    a - current activation
    
    Returns:
    
    SchemaDescriptor the default schema
    
    See Also:
    
    LanguageConnectionContext.getDefaultSchema(Activation a)
  - getCurrentSchemaName
```
public java.lang.String getCurrentSchemaName()
```
    Description copied from interface: LanguageConnectionContext
    
    Get the current schema name (at compile-time, see explanations for getDefaultSchema overloads).
    
    Specified by:
    
    getCurrentSchemaName in interface LanguageConnectionContext
    
    Returns:
    
    SchemaDescriptor the current schema
    
    See Also:
    
    LanguageConnectionContext.getCurrentSchemaName()
  - getCurrentSchemaName
```
public java.lang.String getCurrentSchemaName(Activation a)
```
    Description copied from interface: LanguageConnectionContext
    
    Get the current schema name (at execution time, see explanations for getDefaultSchema overloads); This version is used by CURRENT SCHEMA.
    
    Specified by:
    
    getCurrentSchemaName in interface LanguageConnectionContext
    
    Returns:
    
    SchemaDescriptor the current schema
    
    See Also:
    
    LanguageConnectionContext.getCurrentSchemaName(Activation a)
  - isInitialDefaultSchema
```
public boolean isInitialDefaultSchema(java.lang.String schemaName)
```
    Description copied from interface: LanguageConnectionContext
    
    Return true if this schema name is the initial default schema for the current session.
    
    Specified by:
    
    isInitialDefaultSchema in interface LanguageConnectionContext
    
    Returns:
    
    true
    
    See Also:
    
    LanguageConnectionContext.isInitialDefaultSchema(java.lang.String)
  - setDefaultSchema
```
public void setDefaultSchema(SchemaDescriptor sd)
                      throws StandardException
```
    Description copied from interface: LanguageConnectionContext
    
    Set the default schema (at compile-time, see explanations for getDefaultSchema overloads).
    
    Specified by:
    
    setDefaultSchema in interface LanguageConnectionContext
    
    Parameters:
    
    sd - the new default schema. If null, then the default schema descriptor is used.
    
    Throws:
    
    StandardException - thrown on failure
    
    See Also:
    
    LanguageConnectionContext.setDefaultSchema(SchemaDescriptor sd)
  - setDefaultSchema
```
public void setDefaultSchema(Activation a,
                             SchemaDescriptor sd)
                      throws StandardException
```
    Description copied from interface: LanguageConnectionContext
    
    Set the default schema (at execution time, see explanations for getDefaultSchema overloads); This version is used by SET SCHEMA.
    
    Specified by:
    
    setDefaultSchema in interface LanguageConnectionContext
    
    Parameters:
    
    a - current activation
    
    sd - the new default schema. If null, then the default schema descriptor is used.
    
    Throws:
    
    StandardException - thrown on failure
    
    See Also:
    
    LanguageConnectionContext.setDefaultSchema(Activation a, SchemaDescriptor sd)
  - resetSchemaUsages
```
public void resetSchemaUsages(Activation activation,
                              java.lang.String schemaName)
                       throws StandardException
```
    Description copied from interface: LanguageConnectionContext
    
    Reset any occurence of schemaName as current default schema in the SQLSessionContext stack to the initial default, because schemaName is no longer a valid schema.
    
    Specified by:
    
    resetSchemaUsages in interface LanguageConnectionContext
    
    Parameters:
    
    activation - current activation
    
    schemaName - the schema name occurences of which is to be reset
    
    Throws:
    
    StandardException
    
    See Also:
    
    LanguageConnectionContext.resetSchemaUsages(Activation activation, String schemaName)
  - getIdentityValue
```
public java.lang.Long getIdentityValue()
```
    Get the identity column value most recently generated.
    
    Specified by:
    
    getIdentityValue in interface LanguageConnectionContext
    
    Returns:
    
    the generated identity column value
  - setIdentityValue
```
public void setIdentityValue(long val)
```
    Set the field of most recently generated identity column value.
    
    Specified by:
    
    setIdentityValue in interface LanguageConnectionContext
    
    Parameters:
    
    val - the generated identity column value
  - pushCompilerContext
```
public final CompilerContext pushCompilerContext()
```
    Push a CompilerContext on the context stack with the current default schema as the default schema which we compile against.
    
    Specified by:
    
    pushCompilerContext in interface LanguageConnectionContext
    
    Returns:
    
    the compiler context
  - pushCompilerContext
```
public CompilerContext pushCompilerContext(SchemaDescriptor sd)
```
    Push a CompilerContext on the context stack with the passed in schema sd as the default schema we compile against.
    
    Specified by:
    
    pushCompilerContext in interface LanguageConnectionContext
    
    Parameters:
    
    sd - the default schema
    
    Returns:
    
    the compiler context For the parameter sd, there are 3 possible values(of interest) that can get passed into this method: a) A null SchemaDescriptor which indicates to the system to use the CURRENT SCHEMA as the compilation schema. b) A SchemaDescriptor with its UUID == null, this indicates that either the schema has not been physically created yet or that the LCC's getDefaultSchema() is not yet up-to-date with its actual UUID. The system will use the CURRENT SCHEMA as the compilation schema. c) A SchemaDescriptor with its UUID != null, this means that the schema has been physically created. The system will use this schema as the compilation schema (e.g.: for trigger or view recompilation cases, etc.). The compiler context's compilation schema will be set accordingly based on the given input above.
  - popCompilerContext
```
public void popCompilerContext(CompilerContext cc)
```
    Pop a CompilerContext off the context stack.
    
    Specified by:
    
    popCompilerContext in interface LanguageConnectionContext
    
    Parameters:
    
    cc - The compiler context.
  - pushStatementContext
```
public StatementContext pushStatementContext(boolean isAtomic,
                                             boolean isForReadOnly,
                                             java.lang.String stmtText,
                                             ParameterValueSet pvs,
                                             boolean rollbackParentContext,
                                             long timeoutMillis)
```
    Push a StatementContext on the context stack. Inherit SQL session state a priori (statementContext will get its own SQL session state if this statement executes a call, cf. pushNestedSessionContext.
    
    Specified by:
    
    pushStatementContext in interface LanguageConnectionContext
    
    Parameters:
    
    isAtomic - whether this statement is atomic or not
    
    isForReadOnly - whether this statement is for a read only resultset
    
    stmtText - the text of the statement. Needed for any language statement (currently, for any statement that can cause a trigger to fire). Please set this unless you are some funky jdbc setXXX method or something.
    
    pvs - parameter value set, if it has one
    
    rollbackParentContext - True if 1) the statement context is NOT a top-level context, AND 2) in the event of a statement-level exception, the parent context needs to be rolled back, too.
    
    timeoutMillis - timeout value for this statement, in milliseconds. The value 0 means that no timeout is set.
    
    Returns:
    
    StatementContext The statement context.
  - popStatementContext
```
public void popStatementContext(StatementContext statementContext,
                                java.lang.Throwable error)
```
    Pop a StatementContext of the context stack.
    
    Specified by:
    
    popStatementContext in interface LanguageConnectionContext
    
    Parameters:
    
    statementContext - The statement context.
    
    error - The error, if any (Only relevant for DEBUG)
  - pushExecutionStmtValidator
```
public void pushExecutionStmtValidator(ExecutionStmtValidator validator)
```
    Push a new execution statement validator. An execution statement validator is an object that validates the current statement to ensure that it is permitted given the current execution context. An example of a validator a trigger ExecutionStmtValidator that doesn't allow ddl on the trigger target table.
    Multiple ExecutionStmtValidators may be active at any given time. This mirrors the way there can be multiple connection nestings at a single time. The validation is performed by calling each validator's validateStatement() method. This yields the union of all validations.
    
    Specified by:
    
    pushExecutionStmtValidator in interface LanguageConnectionContext
    
    Parameters:
    
    validator - the validator to add
  - popExecutionStmtValidator
```
public void popExecutionStmtValidator(ExecutionStmtValidator validator)
                               throws StandardException
```
    Remove the validator. Does an object identity (validator == validator) comparison. Asserts that the validator is found.
    
    Specified by:
    
    popExecutionStmtValidator in interface LanguageConnectionContext
    
    Parameters:
    
    validator - the validator to remove
    
    Throws:
    
    StandardException - on error
  - pushTriggerExecutionContext
```
public void pushTriggerExecutionContext(TriggerExecutionContext tec)
                                 throws StandardException
```
    Push a new trigger execution context.
    Multiple TriggerExecutionContexts may be active at any given time.
    
    Specified by:
    
    pushTriggerExecutionContext in interface LanguageConnectionContext
    
    Parameters:
    
    tec - the trigger execution context
    
    Throws:
    
    StandardException - on trigger recursion error
  - popTriggerExecutionContext
```
public void popTriggerExecutionContext(TriggerExecutionContext tec)
                                throws StandardException
```
    Remove the tec. Does an object identity (tec == tec) comparison. Asserts that the tec is found.
    
    Specified by:
    
    popTriggerExecutionContext in interface LanguageConnectionContext
    
    Parameters:
    
    tec - the tec to remove
    
    Throws:
    
    StandardException - on error
  - getTriggerExecutionContext
```
public TriggerExecutionContext getTriggerExecutionContext()
```
    Get the topmost tec.
    
    Specified by:
    
    getTriggerExecutionContext in interface LanguageConnectionContext
    
    Returns:
    
    the tec
  - validateStmtExecution
```
public void validateStmtExecution(ConstantAction constantAction)
                           throws StandardException
```
    Validate a statement. Does so by stepping through all the validators and executing them. If a validator throws and exception, then the checking is stopped and the exception is passed up.
    
    Specified by:
    
    validateStmtExecution in interface LanguageConnectionContext
    
    Parameters:
    
    constantAction - the constantAction that is about to be executed (and should be validated
    
    Throws:
    
    StandardException - on validation failure
  - pushTriggerTable
```
public void pushTriggerTable(TableDescriptor td)
```
    Set the trigger table descriptor. Used to compile statements that may special trigger pseudo tables.
    
    Specified by:
    
    pushTriggerTable in interface LanguageConnectionContext
    
    Parameters:
    
    td - the table that the trigger is defined upon
  - popTriggerTable
```
public void popTriggerTable(TableDescriptor td)
```
    Remove the trigger table descriptor.
    
    Specified by:
    
    popTriggerTable in interface LanguageConnectionContext
    
    Parameters:
    
    td - the table to remove from the stack.
  - getTriggerTable
```
public TableDescriptor getTriggerTable()
```
    Get the topmost trigger table descriptor
    
    Specified by:
    
    getTriggerTable in interface LanguageConnectionContext
    
    Returns:
    
    the table descriptor, or null if we aren't in the middle of compiling a create trigger.
  - getDatabase
```
public Database getDatabase()
```
    Description copied from interface: LanguageConnectionContext
    
    Returns the Database of this connection.
    
    Specified by:
    
    getDatabase in interface LanguageConnectionContext
    
    See Also:
    
    LanguageConnectionContext.getDatabase()
  - incrementBindCount
```
public int incrementBindCount()
```
    Description copied from interface: LanguageConnectionContext
    
    Increment the DataDictionary bind count. This is for keeping track of nested binding, which can happen if SQL statements are bound from within static initializers.
    
    Specified by:
    
    incrementBindCount in interface LanguageConnectionContext
    
    Returns:
    
    The new bind count
    
    See Also:
    
    LanguageConnectionContext.incrementBindCount()
  - decrementBindCount
```
public int decrementBindCount()
```
    Description copied from interface: LanguageConnectionContext
    
    Decrement the DataDictionary bind count.
    
    Specified by:
    
    decrementBindCount in interface LanguageConnectionContext
    
    Returns:
    
    The new bind count
    
    See Also:
    
    LanguageConnectionContext.decrementBindCount()
  - getBindCount
```
public int getBindCount()
```
    Description copied from interface: LanguageConnectionContext
    
    Get the DataDictionary bind count.
    
    Specified by:
    
    getBindCount in interface LanguageConnectionContext
    
    Returns:
    
    The current bind count.
    
    See Also:
    
    LanguageConnectionContext.getBindCount()
  - setDataDictionaryWriteMode
```
public final void setDataDictionaryWriteMode()
```
    Description copied from interface: LanguageConnectionContext
    
    Remember that the DataDictionary is in write mode, so we can take it out of write mode at the end of the transaction.
    
    Specified by:
    
    setDataDictionaryWriteMode in interface LanguageConnectionContext
    
    See Also:
    
    LanguageConnectionContext.setDataDictionaryWriteMode()
  - dataDictionaryInWriteMode
```
public final boolean dataDictionaryInWriteMode()
```
    Description copied from interface: LanguageConnectionContext
    
    Return true if the data dictionary is in write mode (that is, this context was informed that is is in write mode by the method call setDataDictionaryWriteMode().
    
    Specified by:
    
    dataDictionaryInWriteMode in interface LanguageConnectionContext
    
    See Also:
    
    LanguageConnectionContext.dataDictionaryInWriteMode()
  - setRunTimeStatisticsMode
```
public final void setRunTimeStatisticsMode(boolean onOrOff)
```
    Description copied from interface: LanguageConnectionContext
    
    Turn RUNTIMESTATISTICS on or off.
    
    Specified by:
    
    setRunTimeStatisticsMode in interface LanguageConnectionContext
    
    See Also:
    
    LanguageConnectionContext.setRunTimeStatisticsMode(boolean)
  - getRunTimeStatisticsMode
```
public boolean getRunTimeStatisticsMode()
```
    Description copied from interface: LanguageConnectionContext
    
    Get the RUNTIMESTATISTICS mode.
    
    Specified by:
    
    getRunTimeStatisticsMode in interface LanguageConnectionContext
    
    See Also:
    
    LanguageConnectionContext.getRunTimeStatisticsMode()
  - setStatisticsTiming
```
public void setStatisticsTiming(boolean onOrOff)
```
    Description copied from interface: LanguageConnectionContext
    
    Turn STATISTICS TIMING on or off.
    
    Specified by:
    
    setStatisticsTiming in interface LanguageConnectionContext
    
    See Also:
    
    LanguageConnectionContext.setStatisticsTiming(boolean)
  - getStatisticsTiming
```
public boolean getStatisticsTiming()
```
    Description copied from interface: LanguageConnectionContext
    
    Get the STATISTICS TIMING mode.
    
    Specified by:
    
    getStatisticsTiming in interface LanguageConnectionContext
    
    See Also:
    
    LanguageConnectionContext.getStatisticsTiming()
  - setRunTimeStatisticsObject
```
public void setRunTimeStatisticsObject(RunTimeStatistics runTimeStatisticsObject)
```
    Description copied from interface: LanguageConnectionContext
    
    Set the RUNTIMESTATISTICS object.
    
    Specified by:
    
    setRunTimeStatisticsObject in interface LanguageConnectionContext
    
    See Also:
    
    LanguageConnectionContext.setRunTimeStatisticsObject(org.apache.derby.iapi.sql.execute.RunTimeStatistics)
  - getRunTimeStatisticsObject
```
public RunTimeStatistics getRunTimeStatisticsObject()
```
    Description copied from interface: LanguageConnectionContext
    
    Get the RUNTIMESTATISTICS object.
    
    Specified by:
    
    getRunTimeStatisticsObject in interface LanguageConnectionContext
    
    See Also:
    
    LanguageConnectionContext.getRunTimeStatisticsObject()
  - getStatementDepth
```
public int getStatementDepth()
```
    Reports how many statement levels deep we are.
    
    Specified by:
    
    getStatementDepth in interface LanguageConnectionContext
    
    Returns:
    
    a statement level >= OUTERMOST_STATEMENT
  - isIsolationLevelSetUsingSQLorJDBC
```
public boolean isIsolationLevelSetUsingSQLorJDBC()
```
    Description copied from interface: LanguageConnectionContext
    
    Returns true if isolation level has been set using JDBC/SQL.
    
    Specified by:
    
    isIsolationLevelSetUsingSQLorJDBC in interface LanguageConnectionContext
    
    See Also:
    
    LanguageConnectionContext.isIsolationLevelSetUsingSQLorJDBC()
  - resetIsolationLevelFlagUsedForSQLandJDBC
```
public void resetIsolationLevelFlagUsedForSQLandJDBC()
```
    Description copied from interface: LanguageConnectionContext
    
    Reset the isolation level flag used to keep correct isolation level state in BrokeredConnection. This resetting will happen at the start and end of a global transaction, after the BrokeredConection's isolation level state is brought upto date with the EmbedConnection's isolation state. The flag gets set to true when isolation level is set using JDBC/SQL.
    
    Specified by:
    
    resetIsolationLevelFlagUsedForSQLandJDBC in interface LanguageConnectionContext
    
    See Also:
    
    LanguageConnectionContext.resetIsolationLevelFlagUsedForSQLandJDBC()
  - setIsolationLevel
```
public void setIsolationLevel(int isolationLevel)
                       throws StandardException
```
    Description copied from interface: LanguageConnectionContext
    
    Set current isolation level.
    
    Specified by:
    
    setIsolationLevel in interface LanguageConnectionContext
    
    Parameters:
    
    isolationLevel - The new isolationLevel.
    
    Throws:
    
    StandardException
    
    See Also:
    
    LanguageConnectionContext.setIsolationLevel(int)
  - getCurrentIsolationLevel
```
public int getCurrentIsolationLevel()
```
    Description copied from interface: LanguageConnectionContext
    
    Get the current isolation level.
    
    Specified by:
    
    getCurrentIsolationLevel in interface LanguageConnectionContext
    
    Returns:
    
    The current isolation level.
    
    See Also:
    
    LanguageConnectionContext.getCurrentIsolationLevel()
  - getCurrentIsolationLevelStr
```
public java.lang.String getCurrentIsolationLevelStr()
```
    Description copied from interface: LanguageConnectionContext
    
    Get the current isolation level in DB2 format.
    
    Specified by:
    
    getCurrentIsolationLevelStr in interface LanguageConnectionContext
    
    Returns:
    
    The current isolation level as a 2 character string.
    
    See Also:
    
    LanguageConnectionContext.getCurrentIsolationLevel()
  - setPrepareIsolationLevel
```
public void setPrepareIsolationLevel(int level)
```
    Specified by:
    
    setPrepareIsolationLevel in interface LanguageConnectionContext
    
    See Also:
    
    LanguageConnectionContext.setPrepareIsolationLevel(int)
  - getPrepareIsolationLevel
```
public int getPrepareIsolationLevel()
```
    Description copied from interface: LanguageConnectionContext
    
    Get the prepare isolation level. If the isolation level has been explicitly set with a SQL statement or embedded call to setTransactionIsolation, this will return TransactionControl.UNSPECIFIED_ISOLATION_LEVEL SET ISOLATION always takes priority.
    
    Specified by:
    
    getPrepareIsolationLevel in interface LanguageConnectionContext
    
    See Also:
    
    LanguageConnectionContext.getPrepareIsolationLevel()
  - getStatementContext
```
public StatementContext getStatementContext()
```
    Description copied from interface: LanguageConnectionContext
    
    Get the current StatementContext.
    
    Specified by:
    
    getStatementContext in interface LanguageConnectionContext
    
    See Also:
    
    LanguageConnectionContext.getStatementContext()
  - setOptimizerTracer
```
public void setOptimizerTracer(OptTrace tracer)
```
    Description copied from interface: LanguageConnectionContext
    
    Install an optimizer tracer (to enable tracing) or uninstall the current optimizer tracer (to disable tracing).
    
    Specified by:
    
    setOptimizerTracer in interface LanguageConnectionContext
    
    Parameters:
    
    tracer - Null if tracing is being turned off, otherwise an optimizer tracer
    
    See Also:
    
    LanguageConnectionContext.setOptimizerTracer(org.apache.derby.iapi.sql.compile.OptTrace)
  - getOptimizerTracer
```
public OptTrace getOptimizerTracer()
```
    Description copied from interface: LanguageConnectionContext
    
    Get the optimizer tracer (could be null if we aren't tracing the optimizer).
    
    Specified by:
    
    getOptimizerTracer in interface LanguageConnectionContext
    
    See Also:
    
    LanguageConnectionContext.getOptimizerTracer()
  - optimizerTracingIsOn
```
public boolean optimizerTracingIsOn()
```
    Description copied from interface: LanguageConnectionContext
    
    Get whether or not optimizer trace is on.
    
    Specified by:
    
    optimizerTracingIsOn in interface LanguageConnectionContext
    
    Returns:
    
    Whether or not optimizer trace is on.
    
    See Also:
    
    LanguageConnectionContext.optimizerTracingIsOn()
  - isTransactionPristine
```
public boolean isTransactionPristine()
```
    Reports whether there is any outstanding work in the transaction.
    
    Specified by:
    
    isTransactionPristine in interface LanguageConnectionContext
    
    Returns:
    
    true if there is outstanding work in the transaction false otherwise
  - cleanupOnError
```
public void cleanupOnError(java.lang.Throwable error)
                    throws StandardException
```
    If worse than a transaction error, everything goes; we rely on other contexts to kill the context manager for this session.
    If a transaction error, act like we saw a rollback.
    If more severe or a java error, the outer cleanup will shutdown the connection, so we don't have to clean up.
    REMIND: connection should throw out all contexts and start over when the connection is closed... perhaps by throwing out the context manager?
    REVISIT: If statement error, should we do anything?
    Since the access manager's own context takes care of its own resources on errors, there is nothing that this context has to do with the transaction controller.
    
    Specified by:
    
    cleanupOnError in interface Context
    
    Throws:
    
    StandardException - thrown on error. REVISIT: don't want cleanupOnError's to throw exceptions.
  - isLastHandler
```
public boolean isLastHandler(int severity)
```
    Description copied from interface: Context
    
    Return whether or not this context is the "last" handler for a the specified severity level. Previously, the context manager would march through all of the contexts in cleanupOnError() and call each of their cleanupOnError() methods. That did not work with server side JDBC, especially for a StatementException, because outer contexts could get cleaned up incorrectly. This functionality is specific to the Language system. Any non-language system contexts should return ExceptionSeverity.NOT_APPLICABLE_SEVERITY. NOTE: Both the LanguageConnectionContext and the JDBC Connection Context are interested in session level errors because they both have clean up to do. This method allows both of them to return false so that all such handlers under them can do their clean up.
    
    Specified by:
    
    isLastHandler in interface Context
    
    Overrides:
    
    isLastHandler in class ContextImpl
    
    See Also:
    
    Context.isLastHandler(int)
  - getDataDictionary
```
public DataDictionary getDataDictionary()
```
    Description copied from interface: LanguageConnectionContext
    
    Get the data dictionary
    
    Specified by:
    
    getDataDictionary in interface LanguageConnectionContext
    
    Returns:
    
    the data dictionary
  - setReadOnly
```
public void setReadOnly(boolean on)
                 throws StandardException
```
    Description copied from interface: LanguageConnectionContext
    
    Set the readOnly status for the current connection. This can only be called when the current transaction has not done any work.
    
    Specified by:
    
    setReadOnly in interface LanguageConnectionContext
    
    Parameters:
    
    on - true sets the connection to be readOnly and false sets it to readWrite.
    
    Throws:
    
    StandardException - The operation is disallowed.
    
    See Also:
    
    LanguageConnectionContext.setReadOnly(boolean)
  - isReadOnly
```
public boolean isReadOnly()
```
    Description copied from interface: LanguageConnectionContext
    
    Get the readOnly status for the current connection.
    
    Specified by:
    
    isReadOnly in interface LanguageConnectionContext
    
    See Also:
    
    LanguageConnectionContext.isReadOnly()
  - getAuthorizer
```
public Authorizer getAuthorizer()
```
    Description copied from interface: LanguageConnectionContext
    
    Get an Authorizer for this connection.
    
    Specified by:
    
    getAuthorizer in interface LanguageConnectionContext
    
    See Also:
    
    LanguageConnectionContext.getAuthorizer()
  - lastAutoincrementValue
```
public java.lang.Long lastAutoincrementValue(java.lang.String schemaName,
                                             java.lang.String tableName,
                                             java.lang.String columnName)
```
    lastAutoincrementValue searches for the last autoincrement value inserted into a column specified by the user. The search for the "last" value supports nesting levels caused by triggers (Only triggers cause nesting, not server side JDBC). If lastAutoincrementValue is called from within a trigger, the search space for ai-values are those values that are inserted by this trigger as well as previous triggers; i.e if a SQL statement fires trigger T1, which in turn does something that fires trigger t2, and if lastAutoincrementValue is called from within t2, then autoincrement values genereated by t1 are visible to it. By the same logic, if it is called from within t1, then it does not see values inserted by t2.
    
    Specified by:
    
    lastAutoincrementValue in interface LanguageConnectionContext
    
    See Also:
    
    LanguageConnectionContext.lastAutoincrementValue(java.lang.String, java.lang.String, java.lang.String)
  - setAutoincrementUpdate
```
public void setAutoincrementUpdate(boolean flag)
```
    Description copied from interface: LanguageConnectionContext
    
    Sets autoincrementUpdate-- this variable allows updates to autoincrement columns if it is set to true. The default is ofcourse false; i.e ai columns cannot be directly modified by the user. This is set to true by AlterTableConstantAction, when a new ai column is being added to an existing table.
    
    Specified by:
    
    setAutoincrementUpdate in interface LanguageConnectionContext
    
    Parameters:
    
    flag - the value for autoincrementUpdate (TRUE or FALSE)
    
    See Also:
    
    LanguageConnectionContext.setAutoincrementUpdate(boolean)
  - getAutoincrementUpdate
```
public boolean getAutoincrementUpdate()
```
    Description copied from interface: LanguageConnectionContext
    
    Returns the current value of autoincrementUpdate.
    
    Specified by:
    
    getAutoincrementUpdate in interface LanguageConnectionContext
    
    Returns:
    
    true if updates to autoincrement columns is permitted.
    
    See Also:
    
    LanguageConnectionContext.getAutoincrementUpdate()
  - autoincrementCreateCounter
```
public void autoincrementCreateCounter(java.lang.String s,
                                       java.lang.String t,
                                       java.lang.String c,
                                       java.lang.Long initialValue,
                                       long increment,
                                       int position)
```
    Description copied from interface: LanguageConnectionContext
    
    Create an autoincrement counter to be used on behalf of a SQL-J statement. The counter is identified by (schemaName, tableName, columnName). The counter must be freed up by calling autoincrementFlushCache at the end of the statement. It is expected that a ai-counter with the same signaure doesn't exist when the method is called.
    
    Specified by:
    
    autoincrementCreateCounter in interface LanguageConnectionContext
    
    Parameters:
    
    s - SchemaName
    
    t - TableName
    
    c - ColumnName
    
    initialValue - initial value of the counter.
    
    increment - increment for the counter.
    
    position - column position (1-based).
    
    See Also:
    
    LanguageConnectionContext.autoincrementCreateCounter(java.lang.String, java.lang.String, java.lang.String, java.lang.Long, long, int)
  - nextAutoincrementValue
```
public long nextAutoincrementValue(java.lang.String schemaName,
                                   java.lang.String tableName,
                                   java.lang.String columnName)
                            throws StandardException
```
    returns the next value to be inserted into an autoincrement col. This is used internally by the system to generate autoincrement values which are going to be inserted into a autoincrement column. This is used when as autoincrement column is added to a table by an alter table statemenet and during bulk insert.
    
    Specified by:
    
    nextAutoincrementValue in interface LanguageConnectionContext
    
    Parameters:
    
    schemaName -
    
    tableName -
    
    columnName - identify the column uniquely in the system.
    
    Throws:
    
    StandardException - on error.
  - autoincrementFlushCache
```
public void autoincrementFlushCache(UUID tableUUID)
                             throws StandardException
```
    Flush the cache of autoincrement values being kept by the lcc. This will result in the autoincrement values being written to the SYSCOLUMNS table as well as the mapping used by lastAutoincrementValue
    
    Specified by:
    
    autoincrementFlushCache in interface LanguageConnectionContext
    
    Parameters:
    
    tableUUID - the table which is being flushed; we need this value to identify the table for which the autoincrement counter is being maintained.
    
    Throws:
    
    StandardException - thrown on error.
    
    See Also:
    
    LanguageConnectionContext.lastAutoincrementValue(java.lang.String, java.lang.String, java.lang.String), lastAutoincrementValue(java.lang.String, java.lang.String, java.lang.String)
  - copyHashtableToAIHT
```
public void copyHashtableToAIHT(java.util.Map<java.lang.String,java.lang.Long> from)
```
    Copies an existing autoincrement mapping into autoincrementHT, the cache of autoincrement values kept in the languageconnectioncontext.
    
    Specified by:
    
    copyHashtableToAIHT in interface LanguageConnectionContext
  - getInstanceNumber
```
public int getInstanceNumber()
```
    Description copied from interface: LanguageConnectionContext
    
    Get the instance number of this LCC.
    
    Specified by:
    
    getInstanceNumber in interface LanguageConnectionContext
    
    Returns:
    
    instance number of this LCC.
    
    See Also:
    
    LanguageConnectionContext.getInstanceNumber()
  - getDrdaID
```
public java.lang.String getDrdaID()
```
    Description copied from interface: LanguageConnectionContext
    
    Get the DRDA ID of this LCC.
    
    Specified by:
    
    getDrdaID in interface LanguageConnectionContext
    
    Returns:
    
    DRDA ID this LCC.
    
    See Also:
    
    LanguageConnectionContext.getDrdaID()
  - setDrdaID
```
public void setDrdaID(java.lang.String drdaID)
```
    Description copied from interface: LanguageConnectionContext
    
    Set the DRDA ID of this LCC.
    
    Specified by:
    
    setDrdaID in interface LanguageConnectionContext
    
    Parameters:
    
    drdaID - DRDA ID.
    
    See Also:
    
    LanguageConnectionContext.setDrdaID(java.lang.String)
  - getDbname
```
public java.lang.String getDbname()
```
    Description copied from interface: LanguageConnectionContext
    
    Get the database name of this LCC.
    
    Specified by:
    
    getDbname in interface LanguageConnectionContext
    
    Returns:
    
    database name of this LCC.
    
    See Also:
    
    LanguageConnectionContext.getDbname()
  - getLastActivation
```
public Activation getLastActivation()
```
    Description copied from interface: LanguageConnectionContext
    
    Return the last activation added This is used to find the drop activation in dropViewCascade so we can add warning messages to the activation
    
    Specified by:
    
    getLastActivation in interface LanguageConnectionContext
    
    See Also:
    
    LanguageConnectionContext.getLastActivation()
  - appendErrorInfo
```
public java.lang.StringBuffer appendErrorInfo()
```
    Overrides:
    
    appendErrorInfo in class ContextImpl
  - setCurrentRole
```
public void setCurrentRole(Activation a,
                           java.lang.String role)
```
    Description copied from interface: LanguageConnectionContext
    
    Set the current role
    
    Specified by:
    
    setCurrentRole in interface LanguageConnectionContext
    
    Parameters:
    
    a - activation of set role statement
    
    role - the id of the role to be set to current
    
    See Also:
    
    LanguageConnectionContext.setCurrentRole(Activation a, String role)
  - getCurrentRoleId
```
public java.lang.String getCurrentRoleId(Activation a)
```
    Description copied from interface: LanguageConnectionContext
    
    Get the current role authorization identifier of the dynamic call context associated with this activation.
    
    Specified by:
    
    getCurrentRoleId in interface LanguageConnectionContext
    
    Parameters:
    
    a - activation of statement needing current role
    
    Returns:
    
    String the role id
    
    See Also:
    
    LanguageConnectionContext.getCurrentRoleId(Activation a)
  - getCurrentUserId
```
public java.lang.String getCurrentUserId(Activation a)
```
    Description copied from interface: LanguageConnectionContext
    
    Get the Authorization Id of the current user
    
    Specified by:
    
    getCurrentUserId in interface LanguageConnectionContext
    
    Parameters:
    
    a - activation
    
    Returns:
    
    String the authorization id
    
    See Also:
    
    LanguageConnectionContext.getCurrentUserId(Activation a)
  - getCurrentRoleIdDelimited
```
public java.lang.String getCurrentRoleIdDelimited(Activation a)
                                           throws StandardException
```
    Description copied from interface: LanguageConnectionContext
    
    Get the current role authorization identifier in external delimited form (not case normal form) of the dynamic call context associated with this activation.
    
    Specified by:
    
    getCurrentRoleIdDelimited in interface LanguageConnectionContext
    
    Parameters:
    
    a - activation of statement needing current role
    
    Returns:
    
    String the role id in delimited form (i.e. not internal case normal form)
    
    Throws:
    
    StandardException - standard exception policy
    
    See Also:
    
    LanguageConnectionContext.getCurrentRoleIdDelimited(Activation a)
  - roleIsSettable
```
public boolean roleIsSettable(Activation a,
                              java.lang.String role)
                       throws StandardException
```
    Description copied from interface: LanguageConnectionContext
    
    Checks whether the given role can be legally set for the current user. This method will read (potentially) the dictionary, so it needs a transaction context.
    
    Specified by:
    
    roleIsSettable in interface LanguageConnectionContext
    
    Parameters:
    
    a - activation
    
    role - string containing role name
    
    Returns:
    
    true if the role can be set
    
    Throws:
    
    StandardException - standard exception policy
    
    See Also:
    
    LanguageConnectionContext.roleIsSettable(Activation a, String role)
  - getCurrentSQLSessionContext
```
public SQLSessionContext getCurrentSQLSessionContext(Activation activation)
```
    Return the current SQL session context of the activation
    
    Specified by:
    
    getCurrentSQLSessionContext in interface LanguageConnectionContext
    
    Parameters:
    
    activation - the activation
    
    Returns:
    
    The SQL session object
  - pushNestedSessionContext
```
public void pushNestedSessionContext(Activation a,
                                     boolean definersRights,
                                     java.lang.String definer)
                              throws StandardException
```
    Create a new SQL session context for the current activation on the basis of the existing SQL session context. This happens when a stored procedure or function that can contain SQL is invoked, cf. SQL 2003 section 4.27.3, since this gives rise to a nested connection.
    Called from generated code, see StaticMethodCallNode.generatePushNestedSessionContext(org.apache.derby.impl.sql.compile.ActivationClassBuilder, org.apache.derby.iapi.services.compiler.MethodBuilder, boolean, java.lang.String).
    The new SQL session context is also set in the current statement context (of the invocation).
    
    Specified by:
    
    pushNestedSessionContext in interface LanguageConnectionContext
    
    Parameters:
    
    a - activation of the statement which performs the call.
    
    definersRights - if the method should run with definer's rights
    
    definer - authorization id of the definer
    
    Throws:
    
    StandardException - standard error policy
    
    See Also:
    
    StaticMethodCallNode.generatePushNestedSessionContext(org.apache.derby.impl.sql.compile.ActivationClassBuilder, org.apache.derby.iapi.services.compiler.MethodBuilder, boolean, java.lang.String), StatementContext.getSQLSessionContext(), LanguageConnectionContext.setupSubStatementSessionContext(org.apache.derby.iapi.sql.Activation)
  - popNestedSessionContext
```
public void popNestedSessionContext(Activation a)
                             throws StandardException
```
    Description copied from interface: LanguageConnectionContext
    
    If returning from a routine that can execute SQL, perform any actions needed when popping the SQL session context.
    
    Specified by:
    
    popNestedSessionContext in interface LanguageConnectionContext
    
    Parameters:
    
    a - activation
    
    Throws:
    
    StandardException - standard error policy
  - isEffectivelyDeferred
```
public boolean isEffectivelyDeferred(SQLSessionContext sc,
                                     UUID constraintId)
                              throws StandardException
```
    Description copied from interface: LanguageConnectionContext
    
    Determines if a check or foreign key constraint has deferred mode.
    
    Specified by:
    
    isEffectivelyDeferred in interface LanguageConnectionContext
    
    Parameters:
    
    sc - The SQL session context for which we are asking the status
    
    constraintId - The constraint id we are inquiring about.
    
    Returns:
    
    true if the constraint is deferred
    
    Throws:
    
    StandardException - Standard error policy
  - setupSubStatementSessionContext
```
public void setupSubStatementSessionContext(Activation a)
                                     throws StandardException
```
    Description copied from interface: LanguageConnectionContext
    Used when a statement as part of its operation executes an other statement. In contrast to pushNestedSessionContext, the activation (for the substatement) just inherits the current session context from the parent statements activation, it does not push a new copy on the stack of session contexts. Currently, this is used in the following situations:
    - With ALTER TABLE adding a column which has a default values, the default value for all the existing rows is added using an UPDATE substatement.
    - With ALTER TABLE adding a a check constraint, we will use a substatement SELECT to check if all rows satisfy the constraint.
    - ResultSet.insertRow, updateRow and deleteRow.
    - During trigger body execution.
    Specified by:
    
    setupSubStatementSessionContext in interface LanguageConnectionContext
    
    Throws:
    
    StandardException
    
    See Also:
    
    LanguageConnectionContext.setupSubStatementSessionContext(Activation a)
  - getTopLevelSQLSessionContext
```
public SQLSessionContext getTopLevelSQLSessionContext()
```
    Description copied from interface: LanguageConnectionContext
    
    Get the value of top level session context of the top level connection.
    
    Specified by:
    
    getTopLevelSQLSessionContext in interface LanguageConnectionContext
    
    Returns:
    
    the requested session context
    
    See Also:
    
    topLevelSSC
  - createSQLSessionContext
```
public SQLSessionContext createSQLSessionContext()
```
    Description copied from interface: LanguageConnectionContext
    
    Create a fresh SQLSessionContext for this connection.
    
    Specified by:
    
    createSQLSessionContext in interface LanguageConnectionContext
    
    Returns:
    
    new SQLSessionContext
    
    See Also:
    
    LanguageConnectionContext.createSQLSessionContext()
  - getPrintedObjectsMap
```
public java.util.Map<java.lang.Object,java.lang.Object> getPrintedObjectsMap()
```
    Description copied from interface: LanguageConnectionContext
    
    Return a map of AST nodes that have already been printed during a compiler phase, so as to be able to avoid printing a node more than once.
    
    Specified by:
    
    getPrintedObjectsMap in interface LanguageConnectionContext
    
    Returns:
    
    the map
    
    See Also:
    
    LanguageConnectionContext.getPrintedObjectsMap()
  - getXplainOnlyMode
```
public boolean getXplainOnlyMode()
```
    Description copied from interface: LanguageConnectionContext
    
    gets the current set XplainOnlyMode
    
    Specified by:
    
    getXplainOnlyMode in interface LanguageConnectionContext
    
    See Also:
    
    LanguageConnectionContext.getXplainOnlyMode()
  - setXplainOnlyMode
```
public void setXplainOnlyMode(boolean onOrOff)
```
    Description copied from interface: LanguageConnectionContext
    
    sets the XplainOnlyMode. If a connection is in XplainOnlyMode, then the statements are not actually being executed, but are just being compiled and the runtime statistics collected into the XPLAIN tables. This can be set on and off by calling SYSCS_SET_XPLAIN_MODE.
    
    Specified by:
    
    setXplainOnlyMode in interface LanguageConnectionContext
    
    Parameters:
    
    onOrOff - true if statements are to be XPLAINed only.
    
    See Also:
    
    LanguageConnectionContext.setXplainOnlyMode(boolean)
  - getXplainSchema
```
public java.lang.String getXplainSchema()
```
    Description copied from interface: LanguageConnectionContext
    
    gets the current set XplainSchema
    
    Specified by:
    
    getXplainSchema in interface LanguageConnectionContext
    
    Returns:
    
    the Schema of Xplain, may be null.
    
    See Also:
    
    LanguageConnectionContext.getXplainSchema()
  - setXplainSchema
```
public void setXplainSchema(java.lang.String s)
```
    Description copied from interface: LanguageConnectionContext
    
    sets the XplainSchema
    
    Specified by:
    
    setXplainSchema in interface LanguageConnectionContext
    
    Parameters:
    
    s - the schema to use for storing XPLAIN'd statements null means don't store the xplain information non-null means persistent style, use the indicated schema
    
    See Also:
    
    LanguageConnectionContext.setXplainSchema(String)
  - setXplainStatement
```
public void setXplainStatement(java.lang.Object key,
                               java.lang.Object stmt)
```
    Specified by:
    
    setXplainStatement in interface LanguageConnectionContext
  - getXplainStatement
```
public java.lang.Object getXplainStatement(java.lang.Object key)
```
    Specified by:
    
    getXplainStatement in interface LanguageConnectionContext
  - setASTVisitor
```
public void setASTVisitor(ASTVisitor visitor)
```
    Description copied from interface: LanguageConnectionContext
    
    Set a Visitor which walks the AST at various stages. This is useful for poking user-written inspectors into the parse, bind, and optimize phases.
    
    Specified by:
    
    setASTVisitor in interface LanguageConnectionContext
    
    Parameters:
    
    visitor - The Visitor which should walk the tree. Could be null.
  - getASTVisitor
```
public ASTVisitor getASTVisitor()
```
    Description copied from interface: LanguageConnectionContext
    
    Get the Visitor which should walk the AST.
    
    Specified by:
    
    getASTVisitor in interface LanguageConnectionContext
    
    Returns:
    
    The Visitor for that phase. Could be null.
  - setInterruptedException
```
public void setInterruptedException(StandardException e)
```
    Description copied from interface: LanguageConnectionContext
    
    Set the exception created and associated with the detected interruped status flag.
    
    Specified by:
    
    setInterruptedException in interface LanguageConnectionContext
    
    Parameters:
    
    e - the created exception
  - getInterruptedException
```
public StandardException getInterruptedException()
```
    Description copied from interface: LanguageConnectionContext
    
    Get exception created when we detected interruped status flag.
    
    Specified by:
    
    getInterruptedException in interface LanguageConnectionContext
    
    Returns:
    
    saved exception
  - getReferencedColumnMap
```
public FormatableBitSet getReferencedColumnMap(TableDescriptor td)
```
    Description copied from interface: LanguageConnectionContext
    
    Get the referenced column map for a table
    
    Specified by:
    
    getReferencedColumnMap in interface LanguageConnectionContext
    
    Returns:
    
    the map
  - setReferencedColumnMap
```
public void setReferencedColumnMap(TableDescriptor td,
                                   FormatableBitSet map)
```
    Description copied from interface: LanguageConnectionContext
    
    Set the referenced column map for a table
    
    Specified by:
    
    setReferencedColumnMap in interface LanguageConnectionContext
    
    Parameters:
    
    td - the table descriptor
    
    map - the map
  - setConstraintDeferred
```
public void setConstraintDeferred(Activation a,
                                  ConstraintDescriptor cd,
                                  boolean deferred)
                           throws StandardException
```
    Set the constraint mode to deferred for the specified constraint.
    
    Specified by:
    
    setConstraintDeferred in interface LanguageConnectionContext
    
    Parameters:
    
    a - activation
    
    cd - the constraint descriptor
    
    deferred - the constraint mode
    
    Throws:
    
    StandardException - standard error policy
  - checkIntegrity
```
public void checkIntegrity()
                    throws StandardException
```
    Description copied from interface: LanguageConnectionContext
    
    Check that deferred constraints are valid, if not roll back the transaction.
    
    Specified by:
    
    checkIntegrity in interface LanguageConnectionContext
    
    Throws:
    
    StandardException
  - setDeferredAll
```
public void setDeferredAll(Activation a,
                           boolean deferred)
                    throws StandardException
```
    Description copied from interface: LanguageConnectionContext
    
    Set the constraint mode of all deferrable constraints to the value of deferred. If the value is false, this method might throw with a constraint violation error, i.e. if some constraint has deferred mode before this call and had seen violations.
    
    Specified by:
    
    setDeferredAll in interface LanguageConnectionContext
    
    Parameters:
    
    a - The activation
    
    deferred - The value which holds the constraint mode
    
    Throws:
    
    StandardException - Standard error policy
  - getDeferredHashTables
```
public java.util.HashMap<UUID,DeferredConstraintsMemory.ValidationInfo> getDeferredHashTables()
```
    Description copied from interface: LanguageConnectionContext
    
    Get the set of disk backed hash tables containing any index rows saved for deferred unique/PK constraints in this transaction, keyed by the conglomerate id, or rows saved containing row locations violating rows for deferred check constraints.
    
    Specified by:
    
    getDeferredHashTables in interface LanguageConnectionContext
    
    Returns:
    
    the set

Skip navigation links

All Classes

Summary:
Nested |
Field |
Constr |
Method

Detail:
Field |
Constr |
Method

Class GenericLanguageConnectionContext

Field Summary

Fields inherited from interface org.apache.derby.iapi.sql.conn.LanguageConnectionContext

Constructor Summary

Method Summary

Methods inherited from class org.apache.derby.iapi.services.context.ContextImpl

Methods inherited from class java.lang.Object

Methods inherited from interface org.apache.derby.iapi.services.context.Context

Constructor Detail

GenericLanguageConnectionContext

Method Detail

initialize

getLogStatementText

setLogStatementText

getLogQueryPlan

usesSqlAuthorization

getLockEscalationThreshold

addActivation

closeUnusedActivations

notifyUnusedActivation

checkIfAnyDeclaredGlobalTempTablesForThisConnection

addDeclaredGlobalTempTable

dropDeclaredGlobalTempTable

resetFromPool

setLastQueryTree

getLastQueryTree

getTableDescriptorForDeclaredGlobalTempTable

markTempTableAsModifiedInUnitOfWork

prepareInternalStatement

prepareInternalStatement

removeActivation

getActivationCount

lookupCursorActivation

removeStatement

lookupStatement

getUniqueCursorName

getUniqueSavepointName

getUniqueSavepointID

internalCommit

userCommit

internalCommitNoSync

xaCommit

internalRollback

userRollback

xaRollback

internalRollbackToSavepoint

releaseSavePoint

languageSetSavePoint

beginNestedTransaction

commitNestedTransaction

getTransactionCompile

getTransactionExecute

getDataValueFactory

getLanguageFactory

getOptimizerFactory

getLanguageConnectionFactory

verifyAllHeldResultSetsAreClosed

verifyNoOpenResultSets

getSessionUserId

getDefaultSchema

getDefaultSchema

getCurrentSchemaName

getCurrentSchemaName

isInitialDefaultSchema

setDefaultSchema

setDefaultSchema

resetSchemaUsages

getIdentityValue

setIdentityValue

pushCompilerContext

pushCompilerContext

popCompilerContext

pushStatementContext

popStatementContext

pushExecutionStmtValidator

popExecutionStmtValidator

pushTriggerExecutionContext

popTriggerExecutionContext

getTriggerExecutionContext

validateStmtExecution