GenericLanguageConnectionContext (Apache Derby V10.14 Internals)

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
Modifier and Type	Field	Description
`private java.util.ArrayList<Activation>`	`acts`
`private java.util.ArrayList<TempTableInfo>`	`allDeclaredGlobalTempTables`
`private ASTVisitor`	`astWalker`
`protected Authorizer`	`authorizer`
`private java.util.HashMap<java.lang.String,AutoincrementCounter>`	`autoincrementCacheHashtable`
`private java.util.HashMap<java.lang.String,java.lang.Long>`	`autoincrementHT`	To support lastAutoincrementValue: This is a hashtable which maps schemaName,tableName,columnName to a Long value.
`private boolean`	`autoincrementUpdate`	whether to allow updates or not.
`protected int`	`bindCount`
`private SchemaDescriptor`	`cachedInitialDefaultSchemaDescr`	Used to hold the computed value of the initial default schema, cf logic in initDefaultSchemaDescriptor.
`protected LanguageConnectionFactory`	`connFactory`
`private int`	`currentSavepointLevel`
`protected DataValueFactory`	`dataFactory`
`private Database`	`db`
`private java.lang.String`	`dbname`
`private boolean`	`ddWriteMode`
`private int`	`defaultIsolationLevel`
`private java.util.HashMap<UUID,DeferredConstraintsMemory.ValidationInfo>`	`deferredHashTables`	The set of disk backed hash tables containing any index rows saved for deferred constraints in this transaction, keyed by the conglomerate id.
`private java.lang.String`	`drdaID`
`private boolean`	`identityNotNull`
`private long`	`identityVal`
`private int`	`instanceNumber`
`private StandardException`	`interruptedException`	Interrupt status flag of this session's thread, in the form of an exception created where an interrupt was (last) detected during operation, null if no interrupt has been seen.
`protected int`	`isolationLevel`
`private boolean`	`isolationLevelExplicitlySet`
`private boolean`	`isolationLevelSetUsingSQLorJDBC`
`private HeaderPrintWriter`	`istream`
`protected LanguageFactory`	`langFactory`
`private java.lang.Object`	`lastQueryTree`
`private int`	`lockEscalationThreshold`
`private boolean`	`logQueryPlan`
`private boolean`	`logStatementText`
`private int`	`maxActsSize`	The maximum size of acts since the last time it was trimmed.
`protected long`	`nextCursorId`
`protected int`	`nextSavepointId`
`private static int`	`NON_XA`
`protected OptimizerFactory`	`of`
`private OptTrace`	`optimizerTracer`
`protected int`	`outermostTrigger`
`protected int`	`prepareIsolationLevel`
`(package private) java.util.Map<java.lang.Object,java.lang.Object>`	`printedObjectsMap`	This holds 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.
`private int`	`queryNestingDepth`	queryNestingDepth is a counter used to keep track of how many calls have been made to begin read-only nested transactions.
`private TransactionController`	`readOnlyNestedTransaction`	If non-null indicates that a read-only nested user transaction is in progress.
`private java.util.WeakHashMap<TableDescriptor,FormatableBitSet>`	`referencedColumnMap`	Connection local state for cached `TableDescriptor`s used for keeping track of referenced columns for a table during DDL operations.
`private RunTimeStatistics`	`runTimeStatisticsObject`
`private boolean`	`runTimeStatisticsSetting`
`private java.lang.StringBuffer`	`sb`
`private java.lang.String`	`sessionUser`	In contrast to current user id, which may change (inside a routine executing with definer's rights), the sessionUser is constant in a session.
`private StatementContext[]`	`statementContexts`
`private int`	`statementDepth`
`private boolean`	`statisticsTiming`
`private java.util.ArrayList<ExecutionStmtValidator>`	`stmtValidators`
`protected TypeCompilerFactory`	`tcf`
`private SQLSessionContext`	`topLevelSSC`	The top SQL session context stack frame (SQL 2003, section 4.37.3), is kept in topLevelSSC.
`private TransactionController`	`tran`	The transaction to use within this language connection context.
`private java.util.ArrayList<TriggerExecutionContext>`	`triggerExecutionContexts`
`private java.util.ArrayList<TableDescriptor>`	`triggerTables`
`private boolean`	`unusedActs`
`protected java.lang.String`	`userName`
`private static int`	`XA_ONE_PHASE`
`private static int`	`XA_TWO_PHASE`
`private java.lang.String`	`xplain_schema`	the current xplain schema.
`private java.util.Map<java.lang.Object,java.lang.Object>`	`xplain_statements`	For each XPLAIN table, this map stores a SQL INSERT statement which can be prepared and used to insert rows into the table during the capturing of statistics data into the user XPLAIN tables.
`private boolean`	`xplainOnlyMode`	If xplainOnlyMode is set (via SYSCS_SET_XPLAIN_MODE), then the connection does not actually execute statements, but only compiles them, and emits the query plan information into the XPLAIN tables.

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	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	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.
`private boolean`	`checkIfAnyActivationHasHoldCursor(java.lang.String tableName)`	check if there are any activations that reference this temporary table
`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.
`private TableDescriptor`	`cleanupTempTableOnCommitOrRollback(TableDescriptor td, boolean dropAndRedeclare)`	If dropAndRedeclare is true, that means we have come here for temp tables with on commit delete rows and no held curosr open on them.
`private void`	`clearDeferreds()`	Clear deferred information for this transaction.
`void`	`closeUnusedActivations()`	Close any unused activations in this connection context.
`void`	`commitNestedTransaction()`	commit a nested transaction.
`private void`	`compareConstraintModes(SQLSessionContext nested, SQLSessionContext caller)`
`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.
`private void`	`decrementStatementDepth()`	Decrements the statement depth
`protected void`	`doCommit(boolean commitStore, boolean sync, int commitflag, boolean requestedByUser)`	This is where the work on internalCommit(), userCOmmit() and internalCommitNoSync() actually takes place.
`private void`	`doRollback(boolean xa, boolean requestedByUser)`	When a rollback happens, the language connection context will close all open activations and invalidate their prepared statements.
`private void`	`dropAllDeclaredGlobalTempTables()`	Drop all the declared global temporary tables associated with this connection.
`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.
`private void`	`endTransactionActivationHandling(boolean forRollback)`	If we are called as part of rollback code path, then we will reset all the activations that have resultset returning rows associated with them.
`private TempTableInfo`	`findDeclaredGlobalTempTable(java.lang.String tableName)`	Find the declared global temporary table in the list of temporary tables known by this connection.
`private void`	`finishDDTransaction()`	Finish the data dictionary transaction, if any.
`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.
`private SQLSessionContext`	`getCurrentSQLSessionContext()`	Return the current SQL session context based on statement context
`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. the activation argument overload version.
`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.
`private SchemaDescriptor`	`getInitialDefaultSchemaDescriptor()`	Get the computed value for the initial default schema.
`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.
`private java.lang.String`	`getNameString(java.lang.String prefix, long number)`	Build a String for a statement name.
`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.
`private void`	`incrementStatementDepth()`	Increments the statement depth.
`protected SchemaDescriptor`	`initDefaultSchemaDescriptor()`	Compute the initial default schema and set cachedInitialDefaultSchemaDescr accordingly.
`void`	`initialize()`	Initialize.
`void`	`internalCommit(boolean commitStore)`	Do a commit as appropriate for an internally generated commit (e.g. as needed by sync, or autocommit).
`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. as needed by sync, or autocommit).
`void`	`internalRollbackToSavepoint(java.lang.String savepointName, boolean refreshStyle, java.lang.Object kindOfSavepoint)`	Let the context deal with a rollback to savepoint
`private void`	`invalidateCleanupDroppedTable(TableDescriptor td)`	Invalidate a dropped temp table
`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(java.lang.String sqlText)`	Return a PreparedStatement object for the query.
`PreparedStatement`	`prepareInternalStatement(SchemaDescriptor compilationSchema, java.lang.String sqlText, boolean isForReadOnly, boolean forMetaData)`	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.
`private void`	`replaceDeclaredGlobalTempTable(java.lang.String tableName, TableDescriptor td)`	This is called at the commit time for temporary tables with ON COMMIT DELETE ROWS If a temp table with ON COMMIT DELETE ROWS doesn't have any held cursor open on them, we delete the data from them by dropping the conglomerate and recreating the conglomerate.
`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.
`private void`	`resetSavepoints()`	Reset all statement savepoints.
`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.
`protected void`	`resetStatementDepth()`	Resets the statementDepth.
`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.
`private void`	`setupSessionContextMinion(Activation a, boolean push, boolean definersRights, java.lang.String definer)`
`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)`
`private void`	`tempTablesAndCommit(boolean in_xa_transaction)`	Do the necessary work at commit time for temporary tables
`private void`	`tempTablesAndRollback()`	do the necessary work at rollback time for temporary tables 1)If a temp table was declared in the UOW, then drop it and remove it from list of temporary tables. 2)If a temp table was declared and dropped in the UOW, then remove it from list of temporary tables. 3)If an existing temp table was dropped in the UOW, then recreate it with no data. 4)If an existing temp table was modified in the UOW, then get rid of all the rows from the table.
`private void`	`tempTablesReleaseSavepointLevels()`	After a release of a savepoint, we need to go through our temp tables list.
`private void`	`tempTablesXApostCommit()`
`void`	`userCommit()`	Do a commmit as is appropriate for a user requested commit (e.g. a java.sql.Connection.commit() or a language 'COMMIT' statement.
`void`	`userRollback()`	Do a rollback as is appropriate for a user requested rollback (e.g. a java.sql.Connection.rollback() or a language 'ROLLBACk' statement.
`boolean`	`usesSqlAuthorization()`	Check if in SQL standard mode, with support for Grant and Revoke
`private void`	`validateDeferredConstraint(ConstraintDescriptor cd)`	Validate a deferred constraint.
`private void`	`validateDeferredConstraints(boolean rollbackOnError)`	Validate all deferred constraints.
`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 interface org.apache.derby.iapi.services.context.Context
getContextManager, getIdName, popMe, pushMe

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

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

- Field Detail
  - NON_XA
```
private static final int NON_XA
```
    See Also:
    
    Constant Field Values
  - XA_ONE_PHASE
```
private static final int XA_ONE_PHASE
```
    See Also:
    
    Constant Field Values
  - XA_TWO_PHASE
```
private static final int XA_TWO_PHASE
```
    See Also:
    
    Constant Field Values
  - acts
```
private final java.util.ArrayList<Activation> acts
```
  - unusedActs
```
private volatile boolean unusedActs
```
  - maxActsSize
```
private int maxActsSize
```
    The maximum size of acts since the last time it was trimmed. Used to determine whether acts should be trimmed to reclaim space.
  - bindCount
```
protected int bindCount
```
  - ddWriteMode
```
private boolean ddWriteMode
```
  - runTimeStatisticsSetting
```
private boolean runTimeStatisticsSetting
```
  - statisticsTiming
```
private boolean statisticsTiming
```
  - xplainOnlyMode
```
private boolean xplainOnlyMode
```
    If xplainOnlyMode is set (via SYSCS_SET_XPLAIN_MODE), then the connection does not actually execute statements, but only compiles them, and emits the query plan information into the XPLAIN tables.
  - xplain_schema
```
private java.lang.String xplain_schema
```
    the current xplain schema. Is usually NULL. Can be set via SYSCS_SET_XPLAIN_SCHEMA, in which case it species the schema into which XPLAIN information should be stored in user tables.
  - xplain_statements
```
private java.util.Map<java.lang.Object,java.lang.Object> xplain_statements
```
    For each XPLAIN table, this map stores a SQL INSERT statement which can be prepared and used to insert rows into the table during the capturing of statistics data into the user XPLAIN tables.
  - allDeclaredGlobalTempTables
```
private java.util.ArrayList<TempTableInfo> allDeclaredGlobalTempTables
```
  - currentSavepointLevel
```
private int currentSavepointLevel
```
  - nextCursorId
```
protected long nextCursorId
```
  - nextSavepointId
```
protected int nextSavepointId
```
  - runTimeStatisticsObject
```
private RunTimeStatistics runTimeStatisticsObject
```
  - sb
```
private java.lang.StringBuffer sb
```
  - db
```
private Database db
```
  - instanceNumber
```
private final int instanceNumber
```
  - drdaID
```
private java.lang.String drdaID
```
  - dbname
```
private java.lang.String dbname
```
  - lastQueryTree
```
private java.lang.Object lastQueryTree
```
  - tran
```
private final TransactionController tran
```
    The transaction to use within this language connection context. It may be more appropriate to have it in a separate context (LanguageTransactionContext?). REVISIT (nat): I shoehorned the transaction context that the language uses into this class. The main purpose is so that the various language code can find out what its transaction is.
  - readOnlyNestedTransaction
```
private TransactionController readOnlyNestedTransaction
```
    If non-null indicates that a read-only nested user transaction is in progress.
  - queryNestingDepth
```
private int queryNestingDepth
```
    queryNestingDepth is a counter used to keep track of how many calls have been made to begin read-only nested transactions. Only the first call actually starts a Nested User Transaction with the store. Subsequent calls simply increment this counter. commitNestedTransaction only decrements the counter and when it drops to 0 actually commits the nested user transaction.
  - dataFactory
```
protected DataValueFactory dataFactory
```
  - langFactory
```
protected LanguageFactory langFactory
```
  - tcf
```
protected TypeCompilerFactory tcf
```
  - of
```
protected OptimizerFactory of
```
  - connFactory
```
protected LanguageConnectionFactory connFactory
```
  - statementContexts
```
private final StatementContext[] statementContexts
```
  - statementDepth
```
private int statementDepth
```
  - outermostTrigger
```
protected int outermostTrigger
```
  - authorizer
```
protected Authorizer authorizer
```
  - userName
```
protected java.lang.String userName
```
  - topLevelSSC
```
private SQLSessionContext topLevelSSC
```
    The top SQL session context stack frame (SQL 2003, section 4.37.3), is kept in topLevelSSC. For nested session contexts, the SQL session context is held by the activation of the calling statement, cf. pushNestedSessionContext and it is accessible through the current statement context (compile-time), or via the current activation (execution-time).
    
    See Also:
    
    getTopLevelSQLSessionContext()
  - cachedInitialDefaultSchemaDescr
```
private SchemaDescriptor cachedInitialDefaultSchemaDescr
```
    Used to hold the computed value of the initial default schema, cf logic in initDefaultSchemaDescriptor.
  - defaultIsolationLevel
```
private int defaultIsolationLevel
```
  - isolationLevel
```
protected int isolationLevel
```
  - isolationLevelExplicitlySet
```
private boolean isolationLevelExplicitlySet
```
  - isolationLevelSetUsingSQLorJDBC
```
private boolean isolationLevelSetUsingSQLorJDBC
```
  - prepareIsolationLevel
```
protected int prepareIsolationLevel
```
  - logStatementText
```
private boolean logStatementText
```
  - logQueryPlan
```
private boolean logQueryPlan
```
  - istream
```
private HeaderPrintWriter istream
```
  - lockEscalationThreshold
```
private int lockEscalationThreshold
```
  - stmtValidators
```
private java.util.ArrayList<ExecutionStmtValidator> stmtValidators
```
  - triggerExecutionContexts
```
private java.util.ArrayList<TriggerExecutionContext> triggerExecutionContexts
```
  - triggerTables
```
private java.util.ArrayList<TableDescriptor> triggerTables
```
  - optimizerTracer
```
private OptTrace optimizerTracer
```
  - autoincrementHT
```
private java.util.HashMap<java.lang.String,java.lang.Long> autoincrementHT
```
    To support lastAutoincrementValue: This is a hashtable which maps schemaName,tableName,columnName to a Long value.
  - autoincrementUpdate
```
private boolean autoincrementUpdate
```
    whether to allow updates or not.
  - identityVal
```
private long identityVal
```
  - identityNotNull
```
private boolean identityNotNull
```
  - autoincrementCacheHashtable
```
private java.util.HashMap<java.lang.String,AutoincrementCounter> autoincrementCacheHashtable
```
  - astWalker
```
private ASTVisitor astWalker
```
  - interruptedException
```
private StandardException interruptedException
```
    Interrupt status flag of this session's thread, in the form of an exception created where an interrupt was (last) detected during operation, null if no interrupt has been seen.
  - referencedColumnMap
```
private java.util.WeakHashMap<TableDescriptor,FormatableBitSet> referencedColumnMap
```
    Connection local state for cached TableDescriptors used for keeping track of referenced columns for a table during DDL operations.
  - deferredHashTables
```
private java.util.HashMap<UUID,DeferredConstraintsMemory.ValidationInfo> deferredHashTables
```
    The set of disk backed hash tables containing any index rows saved for deferred constraints in this transaction, keyed by the conglomerate id. Checked at commit time, then discarded.
  - sessionUser
```
private java.lang.String sessionUser
```
    In contrast to current user id, which may change (inside a routine executing with definer's rights), the sessionUser is constant in a session.
  - printedObjectsMap
```
java.util.Map<java.lang.Object,java.lang.Object> printedObjectsMap
```
    This holds 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.
    
    See Also:
    
    QueryTreeNode.treePrint(int)
- 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
  - initDefaultSchemaDescriptor
```
protected SchemaDescriptor initDefaultSchemaDescriptor()
                                                throws StandardException
```
    Compute the initial default schema and set cachedInitialDefaultSchemaDescr accordingly.
    
    Returns:
    
    computed initial default schema value for this session
    
    Throws:
    
    StandardException
  - getInitialDefaultSchemaDescriptor
```
private SchemaDescriptor getInitialDefaultSchemaDescriptor()
```
    Get the computed value for the initial default schema.
    
    Returns:
    
    the schema descriptor of the computed initial default schema
  - 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 and 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)
  - tempTablesReleaseSavepointLevels
```
private void tempTablesReleaseSavepointLevels()
```
    After a release of a savepoint, we need to go through our temp tables list. If there are tables with their declare or drop or modified in savepoint levels set to savepoint levels higher than the current savepoint level, then we should change them to the current savepoint level
  - tempTablesAndCommit
```
private void tempTablesAndCommit(boolean in_xa_transaction)
                          throws StandardException
```
    Do the necessary work at commit time for temporary tables
    1)If a temporary table was marked as dropped in this transaction, then remove it from the list of temp tables for this connection 2)If a temporary table was not dropped in this transaction, then mark it's declared savepoint level and modified savepoint level as -1 3)After savepoint fix up, then handle all ON COMMIT DELETE ROWS with no open held cursor temp tables.
    
    Parameters:
    
    in_xa_transaction - if true, then transaction is an XA transaction, and special nested transaction may be necessary to cleanup internal containers supporting the temp tables at commit time.
    
    Throws:
    
    StandardException - Standard exception policy.
  - tempTablesXApostCommit
```
private void tempTablesXApostCommit()
                             throws StandardException
```
    Throws:
    
    StandardException
  - 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
  - dropAllDeclaredGlobalTempTables
```
private void dropAllDeclaredGlobalTempTables()
                                      throws StandardException
```
    Drop all the declared global temporary tables associated with this connection. This gets called when a getConnection() is done on a PooledConnection. This will ensure all the temporary tables declared on earlier connection handle associated with this physical database connection are dropped before a new connection handle is issued on that same physical database connection.
    
    Throws:
    
    StandardException
  - tempTablesAndRollback
```
private void tempTablesAndRollback()
                            throws StandardException
```
    do the necessary work at rollback time for temporary tables 1)If a temp table was declared in the UOW, then drop it and remove it from list of temporary tables. 2)If a temp table was declared and dropped in the UOW, then remove it from list of temporary tables. 3)If an existing temp table was dropped in the UOW, then recreate it with no data. 4)If an existing temp table was modified in the UOW, then get rid of all the rows from the table.
    
    Throws:
    
    StandardException
  - invalidateCleanupDroppedTable
```
private void invalidateCleanupDroppedTable(TableDescriptor td)
                                    throws StandardException
```
    Invalidate a dropped temp table
    
    Throws:
    
    StandardException
  - replaceDeclaredGlobalTempTable
```
private void replaceDeclaredGlobalTempTable(java.lang.String tableName,
                                            TableDescriptor td)
```
    This is called at the commit time for temporary tables with ON COMMIT DELETE ROWS If a temp table with ON COMMIT DELETE ROWS doesn't have any held cursor open on them, we delete the data from them by dropping the conglomerate and recreating the conglomerate. In order to store the new conglomerate information for the temp table, we need to replace the existing table descriptor with the new table descriptor which has the new conglomerate information
    
    Parameters:
    
    tableName - Temporary table name whose table descriptor is getting changed
    
    td - New table descriptor for the temporary table
  - 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)
  - findDeclaredGlobalTempTable
```
private TempTableInfo findDeclaredGlobalTempTable(java.lang.String tableName)
```
    Find the declared global temporary table in the list of temporary tables known by this connection.
    
    Parameters:
    
    tableName - look for this table name in the saved list
    
    Returns:
    
    data structure defining the temporary table if found. Else, return null
  - 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
  - getNameString
```
private java.lang.String getNameString(java.lang.String prefix,
                                       long number)
```
    Build a String for a statement name.
    
    Parameters:
    
    prefix - The prefix for the statement name.
    
    number - The number to append for uniqueness
    
    Returns:
    
    A unique String for a statement name.
  - 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
  - doCommit
```
protected void doCommit(boolean commitStore,
                        boolean sync,
                        int commitflag,
                        boolean requestedByUser)
                 throws StandardException
```
    This is where the work on internalCommit(), userCOmmit() and internalCommitNoSync() actually takes place.
    When a commit happens, the language connection context will close all open activations/cursors and commit the Store transaction.
    REVISIT: we talked about having a LanguageTransactionContext, but since store transaction management is currently in flux and our context might want to delegate to that context, for now all commit/rollback actions are handled directly by the language connection context. REVISIT: this may need additional alterations when RELEASE SAVEPOINT/ROLLBACK TO SAVEPOINT show up.
    Since the access manager's own context takes care of its own resources on commit, and the transaction stays open, there is nothing that this context has to do with the transaction controller.
    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.
    
    Parameters:
    
    commitStore - true if we should commit the Store transaction
    
    sync - true means do a synchronized commit, false means do an unsynchronized commit
    
    commitflag - if this is an unsynchronized commit, the flags to pass to commitNoSync in the store's TransactionController. If this is a synchronized commit, this flag is overloaded for xacommit.
    
    requestedByUser - False iff the commit is for internal use and we should ignore the check to prevent commits in an atomic statement.
    
    Throws:
    
    StandardException - Thrown on error
  - cleanupTempTableOnCommitOrRollback
```
private TableDescriptor cleanupTempTableOnCommitOrRollback(TableDescriptor td,
                                                           boolean dropAndRedeclare)
                                                    throws StandardException
```
    If dropAndRedeclare is true, that means we have come here for temp tables with on commit delete rows and no held curosr open on them. We will drop the existing conglomerate and redeclare a new conglomerate similar to old conglomerate. This is a more efficient way of deleting all rows from the table. If dropAndRedeclare is false, that means we have come here for the rollback cleanup work. We are trying to restore old definition of the temp table (because the drop on it is being rolled back).
    
    Throws:
    
    StandardException
  - 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
  - doRollback
```
private void doRollback(boolean xa,
                        boolean requestedByUser)
                 throws StandardException
```
    When a rollback happens, the language connection context will close all open activations and invalidate their prepared statements. Then the language will abort the Store transaction.
    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.
    
    Parameters:
    
    xa - true if this is an xa rollback
    
    requestedByUser - true if requested by user
    
    Throws:
    
    StandardException - thrown on failure
  - resetSavepoints
```
private void resetSavepoints()
                      throws StandardException
```
    Reset all statement savepoints. Traverses the StatementContext stack from bottom to top, calling resetSavePoint() on each element.
    
    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
  - checkIfAnyActivationHasHoldCursor
```
private boolean checkIfAnyActivationHasHoldCursor(java.lang.String tableName)
                                           throws StandardException
```
    check if there are any activations that reference this temporary table
    
    Parameters:
    
    tableName - look for any activations referencing this table name
    
    Returns:
    
    boolean false if found no activations
    
    Throws:
    
    StandardException
  - 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)
  - endTransactionActivationHandling
```
private void endTransactionActivationHandling(boolean forRollback)
                                       throws StandardException
```
    If we are called as part of rollback code path, then we will reset all the activations that have resultset returning rows associated with them. DERBY-3304 Resultsets that do not return rows should be left alone when the rollback is through the JDBC Connection object. If the rollback is caused by an exception, then at that time, all kinds of resultsets should be closed. If we are called as part of commit code path, then we will do one of the following if the activation has resultset assoicated with it. Also, we will clear the conglomerate used while scanning for update/delete 1)Close result sets that return rows and are not held across commit. 2)Clear the current row of the resultsets that return rows and are held across commit. 3)Leave the result sets untouched if they do not return rows Additionally, clean up (close()) activations that have been marked as unused during statement finalization.
    
    Throws:
    
    StandardException - thrown on failure
  - finishDDTransaction
```
private void finishDDTransaction()
                          throws StandardException
```
    Finish the data dictionary transaction, if any.
    
    Throws:
    
    StandardException - Thrown on error
  - incrementStatementDepth
```
private void incrementStatementDepth()
```
    Increments the statement depth.
  - decrementStatementDepth
```
private void decrementStatementDepth()
```
    Decrements the statement depth
  - resetStatementDepth
```
protected void resetStatementDepth()
```
    Resets the statementDepth.
  - 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
  - getCurrentSQLSessionContext
```
private SQLSessionContext getCurrentSQLSessionContext()
```
    Return the current SQL session context based on statement context
  - 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)
  - setupSessionContextMinion
```
private void setupSessionContextMinion(Activation a,
                                       boolean push,
                                       boolean definersRights,
                                       java.lang.String definer)
                                throws StandardException
```
    Throws:
    
    StandardException
  - 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
  - compareConstraintModes
```
private void compareConstraintModes(SQLSessionContext nested,
                                    SQLSessionContext caller)
                             throws StandardException
```
    Throws:
    
    StandardException
  - 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
  - clearDeferreds
```
private void clearDeferreds()
```
    Clear deferred information for this transaction.
  - 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
  - validateDeferredConstraints
```
private void validateDeferredConstraints(boolean rollbackOnError)
                                  throws StandardException
```
    Validate all deferred constraints.
    
    Throws:
    
    StandardException
  - validateDeferredConstraint
```
private void validateDeferredConstraint(ConstraintDescriptor cd)
                                 throws StandardException
```
    Validate a deferred constraint.
    
    Parameters:
    
    cd - the descriptor of the constraint to validate
    
    Throws:
    
    StandardException

Class GenericLanguageConnectionContext

Field Summary

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

Constructor Summary

Method Summary

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

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

Methods inherited from class java.lang.Object

Field Detail

NON_XA

XA_ONE_PHASE

XA_TWO_PHASE

acts

unusedActs

maxActsSize

bindCount

ddWriteMode

runTimeStatisticsSetting

statisticsTiming

xplainOnlyMode

xplain_schema

xplain_statements

allDeclaredGlobalTempTables

currentSavepointLevel

nextCursorId

nextSavepointId

runTimeStatisticsObject

sb

db

instanceNumber

drdaID

dbname

lastQueryTree

tran

readOnlyNestedTransaction

queryNestingDepth

dataFactory

langFactory

tcf

of

connFactory

statementContexts

statementDepth

outermostTrigger

authorizer

userName

topLevelSSC

cachedInitialDefaultSchemaDescr

defaultIsolationLevel

isolationLevel

isolationLevelExplicitlySet

isolationLevelSetUsingSQLorJDBC

prepareIsolationLevel

logStatementText

logQueryPlan

istream

lockEscalationThreshold

stmtValidators

triggerExecutionContexts

triggerTables

optimizerTracer

autoincrementHT

autoincrementUpdate

identityVal

identityNotNull

autoincrementCacheHashtable

astWalker

interruptedException

referencedColumnMap

deferredHashTables

sessionUser

printedObjectsMap

Constructor Detail

GenericLanguageConnectionContext

Method Detail

initialize

initDefaultSchemaDescriptor

getInitialDefaultSchemaDescriptor

getLogStatementText

setLogStatementText