Uses of Class
org.h2.engine.Session

Packages that use Session
org.h2.command This package contains the parser and the base classes for prepared SQL statements. 
org.h2.command.ddl Contains DDL (data definition language) and related SQL statements. 
org.h2.command.dml Contains DML (data manipulation language) and related SQL statements. 
org.h2.constraint Database constraints such as check constraints, unique constraints, and referential constraints. 
org.h2.engine Contains high level classes of the database and classes that don't fit in another sub-package. 
org.h2.expression Expressions include mathematical operations, conditions, simple values, and functions. 
org.h2.index Various table index implementations, as well as cursors to navigate in an index. 
org.h2.result Implementation of row and internal result sets. 
org.h2.schema Schema implementation and objects that are stored in a schema (for example, sequences and constants). 
org.h2.store Storage abstractions, such as a file with a cache, or a class to convert values to a byte array and vice versa. 
org.h2.table Classes related to a table and table meta data. 
 

Uses of Session in org.h2.command
 

Fields in org.h2.command declared as Session
protected  Session Command.session
          The session.
protected  Session Prepared.session
          The session.
 

Methods in org.h2.command that return Session
 Session Parser.getSession()
           
 

Methods in org.h2.command with parameters of type Session
 void Prepared.setSession(Session currentSession)
          Set the session for this statement.
 

Constructors in org.h2.command with parameters of type Session
Parser(Session session)
           
Prepared(Session session)
          Create a new object.
 

Uses of Session in org.h2.command.ddl
 

Fields in org.h2.command.ddl declared as Session
 Session CreateTableData.session
          The session.
 

Methods in org.h2.command.ddl with parameters of type Session
static void Analyze.analyzeTable(Session session, Table table, int sample, boolean manual)
          Analyze this table.
 

Constructors in org.h2.command.ddl with parameters of type Session
AlterIndexRename(Session session)
           
AlterSchemaRename(Session session)
           
AlterTableAddConstraint(Session session, Schema schema, boolean ifNotExists)
           
AlterTableAlterColumn(Session session, Schema schema)
           
AlterTableDropConstraint(Session session, Schema schema, boolean ifExists)
           
AlterTableRename(Session session, Schema schema)
           
AlterTableRenameColumn(Session session)
           
AlterUser(Session session)
           
AlterView(Session session)
           
Analyze(Session session)
           
CreateAggregate(Session session)
           
CreateConstant(Session session, Schema schema)
           
CreateFunctionAlias(Session session, Schema schema)
           
CreateIndex(Session session, Schema schema)
           
CreateLinkedTable(Session session, Schema schema)
           
CreateRole(Session session)
           
CreateSchema(Session session)
           
CreateSequence(Session session, Schema schema)
           
CreateTable(Session session, Schema schema)
           
CreateTrigger(Session session, Schema schema)
           
CreateUser(Session session)
           
CreateUserDataType(Session session)
           
CreateView(Session session, Schema schema)
           
DeallocateProcedure(Session session)
           
DefineCommand(Session session)
          Create a new command for the given session.
DropAggregate(Session session)
           
DropConstant(Session session, Schema schema)
           
DropDatabase(Session session)
           
DropFunctionAlias(Session session, Schema schema)
           
DropIndex(Session session, Schema schema)
           
DropRole(Session session)
           
DropSchema(Session session)
           
DropSequence(Session session, Schema schema)
           
DropTable(Session session, Schema schema)
           
DropTrigger(Session session, Schema schema)
           
DropUser(Session session)
           
DropUserDataType(Session session)
           
DropView(Session session, Schema schema)
           
GrantRevoke(Session session)
           
PrepareProcedure(Session session)
           
SchemaCommand(Session session, Schema schema)
          Create a new command.
SetComment(Session session)
           
TruncateTable(Session session)
           
 

Uses of Session in org.h2.command.dml
 

Methods in org.h2.command.dml with parameters of type Session
abstract  void Query.updateAggregate(Session s)
          Update all aggregate function values.
 void Select.updateAggregate(Session s)
           
 void SelectUnion.updateAggregate(Session s)
           
 

Constructors in org.h2.command.dml with parameters of type Session
AlterSequence(Session session, Schema schema)
           
AlterTableSet(Session session, Schema schema, int type, boolean value)
           
BackupCommand(Session session)
           
Call(Session session)
           
Delete(Session session)
           
ExecuteProcedure(Session session)
           
Explain(Session session)
           
Insert(Session session)
           
Merge(Session session)
           
NoOperation(Session session)
           
Query(Session session)
           
RunScriptCommand(Session session)
           
ScriptBase(Session session)
           
ScriptCommand(Session session)
           
Select(Session session)
           
SelectUnion(Session session, Query query)
           
Set(Session session, int type)
           
TransactionCommand(Session session, int type)
           
Update(Session session)
           
 

Uses of Session in org.h2.constraint
 

Methods in org.h2.constraint with parameters of type Session
abstract  void Constraint.checkExistingData(Session session)
          Check the existing data.
 void ConstraintCheck.checkExistingData(Session session)
           
 void ConstraintReferential.checkExistingData(Session session)
           
 void ConstraintUnique.checkExistingData(Session session)
           
abstract  void Constraint.checkRow(Session session, Table t, Row oldRow, Row newRow)
          Check if this row fulfils the constraint.
 void ConstraintCheck.checkRow(Session session, Table t, Row oldRow, Row newRow)
           
 void ConstraintReferential.checkRow(Session session, Table t, Row oldRow, Row newRow)
           
 void ConstraintUnique.checkRow(Session session, Table t, Row oldRow, Row newRow)
           
 void ConstraintCheck.removeChildrenAndResources(Session session)
           
 void ConstraintReferential.removeChildrenAndResources(Session session)
           
 void ConstraintUnique.removeChildrenAndResources(Session session)
           
 

Uses of Session in org.h2.engine
 

Methods in org.h2.engine that return Session
 Session Engine.createSession(ConnectionInfo ci)
          Open a database connection with the given connection information.
 Session Database.createSession(User user)
          Create a session for the given user.
 Session Database.getExclusiveSession()
           
 Session[] Database.getSessions(boolean includingSystemSession)
          Get all sessions that are currently connected to the database.
 Session Database.getSystemSession()
           
 

Methods in org.h2.engine with parameters of type Session
 void Database.addDatabaseObject(Session session, DbObject obj)
          Add an object to the database.
 void Database.addSchemaObject(Session session, SchemaObject obj)
          Add a schema object to the database.
 void Database.commit(Session session)
          Commit the current transaction of the given session.
 java.lang.String Database.getTempTableName(Session session)
          Get a unique temporary table name.
 Value FunctionAlias.JavaMethod.getValue(Session session, Expression[] args, boolean columnList)
          Call the user-defined function and return the value.
 void Database.prepareCommit(Session session, java.lang.String transaction)
          Prepare a transaction.
 void Comment.removeChildrenAndResources(Session session)
           
 void DbObject.removeChildrenAndResources(Session session)
          Delete all dependent children objects and resources of this object.
abstract  void DbObjectBase.removeChildrenAndResources(Session session)
          Remove all dependent objects and free all resources (files, blocks in files) of this object.
 void FunctionAlias.removeChildrenAndResources(Session session)
           
 void Right.removeChildrenAndResources(Session session)
           
 void Role.removeChildrenAndResources(Session session)
           
 void Setting.removeChildrenAndResources(Session session)
           
 void User.removeChildrenAndResources(Session session)
           
 void UserAggregate.removeChildrenAndResources(Session session)
           
 void UserDataType.removeChildrenAndResources(Session session)
           
 void Database.removeDatabaseObject(Session session, DbObject obj)
          Remove the object from the database.
 void Database.removeMeta(Session session, int id)
          Remove the given object from the meta data.
 void Database.removeSchemaObject(Session session, SchemaObject obj)
          Remove an object from the system table.
 void Database.removeSession(Session session)
          Remove a session.
 void Database.renameDatabaseObject(Session session, DbObject obj, java.lang.String newName)
          Rename a database object.
 void Database.renameSchemaObject(Session session, SchemaObject obj, java.lang.String newName)
          Rename a schema object.
 void Database.setExclusiveSession(Session session, boolean closeOthers)
          Set the session that can exclusively access the database.
 void UndoLogRecord.undo(Session session)
          Un-do the operation.
 void Database.update(Session session, DbObject obj)
          Update an object in the system table.
 

Constructors in org.h2.engine with parameters of type Session
UndoLog(Session session)
          Create a new undo log for the given session.
 

Uses of Session in org.h2.expression
 

Methods in org.h2.expression with parameters of type Session
 void CompareLike.createIndexConditions(Session session, TableFilter filter)
           
 void Comparison.createIndexConditions(Session session, TableFilter filter)
           
 void ConditionAndOr.createIndexConditions(Session session, TableFilter filter)
           
 void ConditionIn.createIndexConditions(Session session, TableFilter filter)
           
 void ConditionInSelect.createIndexConditions(Session session, TableFilter filter)
           
 void Expression.createIndexConditions(Session session, TableFilter filter)
          Create index conditions if possible and attach them to the table filter.
 void ExpressionColumn.createIndexConditions(Session session, TableFilter filter)
           
 void ValueExpression.createIndexConditions(Session session, TableFilter filter)
           
 Expression ConditionIn.getAdditional(Session session, Comparison other)
          Add an additional element if possible.
 java.lang.Boolean Expression.getBooleanValue(Session session)
          Get the value in form of a boolean expression.
 Expression[] Expression.getExpressionColumns(Session session)
          If this expression consists of column expressions it should return them.
 Expression[] ExpressionList.getExpressionColumns(Session session)
           
 Expression[] JavaFunction.getExpressionColumns(Session session)
           
 Expression[] Subquery.getExpressionColumns(Session session)
           
 Expression[] TableFunction.getExpressionColumns(Session session)
           
 Expression[] ValueExpression.getExpressionColumns(Session session)
           
static Expression[] Expression.getExpressionColumns(Session session, java.sql.ResultSet rs)
          Extracts expression columns from the given result set.
static Expression[] Expression.getExpressionColumns(Session session, ValueArray value)
          Extracts expression columns from ValueArray
 Expression Comparison.getNotIfPossible(Session session)
           
 Expression ConditionAndOr.getNotIfPossible(Session session)
           
 Expression ConditionNot.getNotIfPossible(Session session)
           
 Expression Expression.getNotIfPossible(Session session)
          If it is possible, return the negated expression.
 Expression ExpressionColumn.getNotIfPossible(Session session)
           
 Expression Parameter.getNotIfPossible(Session session)
           
 Expression ValueExpression.getNotIfPossible(Session session)
           
 Value Aggregate.getValue(Session session)
           
 Value Alias.getValue(Session session)
           
 Value CompareLike.getValue(Session session)
           
 Value Comparison.getValue(Session session)
           
 Value ConditionAndOr.getValue(Session session)
           
 Value ConditionExists.getValue(Session session)
           
 Value ConditionIn.getValue(Session session)
           
 Value ConditionInSelect.getValue(Session session)
           
 Value ConditionNot.getValue(Session session)
           
abstract  Value Expression.getValue(Session session)
          Return the resulting value for the current row.
 Value ExpressionColumn.getValue(Session session)
           
 Value ExpressionList.getValue(Session session)
           
 Value Function.getValue(Session session)
           
 Value FunctionCall.getValue(Session session)
          Calculate the result.
 Value JavaAggregate.getValue(Session session)
           
 Value JavaFunction.getValue(Session session)
           
 Value Operation.getValue(Session session)
           
 Value Parameter.getValue(Session session)
           
 Value Rownum.getValue(Session session)
           
 Value SequenceValue.getValue(Session session)
           
 Value Subquery.getValue(Session session)
           
 Value TableFunction.getValue(Session session)
           
 Value ValueExpression.getValue(Session session)
           
 Value Variable.getValue(Session session)
           
 Value Wildcard.getValue(Session session)
           
 ValueResultSet Function.getValueForColumnList(Session session, Expression[] argList)
           
 ValueResultSet FunctionCall.getValueForColumnList(Session session, Expression[] nullArgs)
          Get an empty result set with the column names set.
 ValueResultSet JavaFunction.getValueForColumnList(Session session, Expression[] argList)
           
 ValueResultSet TableFunction.getValueForColumnList(Session session, Expression[] nullArgs)
           
 Expression Aggregate.optimize(Session session)
           
 Expression Alias.optimize(Session session)
           
 Expression CompareLike.optimize(Session session)
           
 Expression Comparison.optimize(Session session)
           
 Expression ConditionAndOr.optimize(Session session)
           
 Expression ConditionExists.optimize(Session session)
           
 Expression ConditionIn.optimize(Session session)
           
 Expression ConditionInSelect.optimize(Session session)
           
 Expression ConditionNot.optimize(Session session)
           
abstract  Expression Expression.optimize(Session session)
          Try to optimize the expression.
 Expression ExpressionColumn.optimize(Session session)
           
 Expression ExpressionList.optimize(Session session)
           
 Expression Function.optimize(Session session)
           
 Expression FunctionCall.optimize(Session session)
          Optimize the function if possible.
 Expression JavaAggregate.optimize(Session session)
           
 Expression JavaFunction.optimize(Session session)
           
 Expression Operation.optimize(Session session)
           
 Expression Parameter.optimize(Session session)
           
 Expression Rownum.optimize(Session session)
           
 Expression SequenceValue.optimize(Session session)
           
 Expression Subquery.optimize(Session session)
           
 Expression ValueExpression.optimize(Session session)
           
 Expression Variable.optimize(Session session)
           
 Expression Wildcard.optimize(Session session)
           
 void Aggregate.updateAggregate(Session session)
           
 void Alias.updateAggregate(Session session)
           
 void CompareLike.updateAggregate(Session session)
           
 void Comparison.updateAggregate(Session session)
           
 void ConditionAndOr.updateAggregate(Session session)
           
 void ConditionExists.updateAggregate(Session session)
           
 void ConditionIn.updateAggregate(Session session)
           
 void ConditionInSelect.updateAggregate(Session session)
           
 void ConditionNot.updateAggregate(Session session)
           
abstract  void Expression.updateAggregate(Session session)
          Update an aggregate value.
 void ExpressionColumn.updateAggregate(Session session)
           
 void ExpressionList.updateAggregate(Session session)
           
 void Function.updateAggregate(Session session)
           
 void JavaAggregate.updateAggregate(Session session)
           
 void JavaFunction.updateAggregate(Session session)
           
 void Operation.updateAggregate(Session session)
           
 void Parameter.updateAggregate(Session session)
           
 void Rownum.updateAggregate(Session session)
           
 void SequenceValue.updateAggregate(Session session)
           
 void Subquery.updateAggregate(Session session)
           
 void ValueExpression.updateAggregate(Session session)
           
 void Variable.updateAggregate(Session session)
           
 void Wildcard.updateAggregate(Session session)
           
 

Constructors in org.h2.expression with parameters of type Session
Comparison(Session session, int compareType, Expression left, Expression right)
           
Variable(Session session, java.lang.String name)
           
 

Uses of Session in org.h2.index
 

Methods in org.h2.index that return Session
 Session ViewIndex.getSession()
           
 

Methods in org.h2.index with parameters of type Session
abstract  void BaseIndex.add(Session session, Row row)
          Add a row to this index.
 void FunctionIndex.add(Session session, Row row)
           
 void HashIndex.add(Session session, Row row)
           
 void Index.add(Session session, Row row)
          Add a row to the index.
 void LinkedIndex.add(Session session, Row row)
           
 void MetaIndex.add(Session session, Row row)
           
 void MultiVersionIndex.add(Session session, Row row)
           
 void NonUniqueHashIndex.add(Session session, Row row)
           
 void PageBtreeIndex.add(Session session, Row row)
           
 void PageDataIndex.add(Session session, Row row)
           
 void PageDelegateIndex.add(Session session, Row row)
           
 void RangeIndex.add(Session session, Row row)
           
 void ScanIndex.add(Session session, Row row)
           
 void TreeIndex.add(Session session, Row row)
           
 void ViewIndex.add(Session session, Row row)
           
abstract  void BaseIndex.close(Session session)
          Close this index.
 void FunctionIndex.close(Session session)
           
 void HashIndex.close(Session session)
           
 void Index.close(Session session)
          Close this index.
 void LinkedIndex.close(Session session)
           
 void MetaIndex.close(Session session)
           
 void MultiVersionIndex.close(Session session)
           
 void PageBtreeIndex.close(Session session)
           
 void PageDataIndex.close(Session session)
           
 void PageDelegateIndex.close(Session session)
           
 void RangeIndex.close(Session session)
           
 void ScanIndex.close(Session session)
           
 void TreeIndex.close(Session session)
           
 void ViewIndex.close(Session session)
           
 void IndexCursor.find(Session s, java.util.ArrayList<IndexCondition> indexConditions)
          Re-evaluate the start and end values of the index search for rows.
abstract  Cursor BaseIndex.find(Session session, SearchRow first, SearchRow last)
          Create a cursor to iterate over a number of rows.
 Cursor FunctionIndex.find(Session session, SearchRow first, SearchRow last)
           
 Cursor HashIndex.find(Session session, SearchRow first, SearchRow last)
           
 Cursor Index.find(Session session, SearchRow first, SearchRow last)
          Find a row or a list of rows and create a cursor to iterate over the result.
 Cursor LinkedIndex.find(Session session, SearchRow first, SearchRow last)
           
 Cursor MetaIndex.find(Session session, SearchRow first, SearchRow last)
           
 Cursor MultiVersionIndex.find(Session session, SearchRow first, SearchRow last)
           
 Cursor NonUniqueHashIndex.find(Session session, SearchRow first, SearchRow last)
           
 Cursor PageBtreeIndex.find(Session session, SearchRow first, SearchRow last)
           
 Cursor PageDataIndex.find(Session session, SearchRow first, SearchRow last)
           
 Cursor PageDelegateIndex.find(Session session, SearchRow first, SearchRow last)
           
 Cursor RangeIndex.find(Session session, SearchRow first, SearchRow last)
           
 Cursor ScanIndex.find(Session session, SearchRow first, SearchRow last)
           
 Cursor TreeIndex.find(Session session, SearchRow first, SearchRow last)
           
 Cursor ViewIndex.find(Session session, SearchRow first, SearchRow last)
           
abstract  Cursor BaseIndex.findFirstOrLast(Session session, boolean first)
          Find the first (or last) value of this index.
 Cursor FunctionIndex.findFirstOrLast(Session session, boolean first)
           
 Cursor HashIndex.findFirstOrLast(Session session, boolean first)
           
 Cursor Index.findFirstOrLast(Session session, boolean first)
          Find the lowest or highest value of a column.
 Cursor LinkedIndex.findFirstOrLast(Session session, boolean first)
           
 Cursor MetaIndex.findFirstOrLast(Session session, boolean first)
           
 Cursor MultiVersionIndex.findFirstOrLast(Session session, boolean first)
           
 Cursor PageBtreeIndex.findFirstOrLast(Session session, boolean first)
           
 Cursor PageDataIndex.findFirstOrLast(Session session, boolean first)
           
 Cursor PageDelegateIndex.findFirstOrLast(Session session, boolean first)
           
 Cursor RangeIndex.findFirstOrLast(Session session, boolean first)
           
 Cursor ScanIndex.findFirstOrLast(Session session, boolean first)
           
 Cursor TreeIndex.findFirstOrLast(Session session, boolean first)
           
 Cursor ViewIndex.findFirstOrLast(Session session, boolean first)
           
 Cursor BaseIndex.findNext(Session session, SearchRow higherThan, SearchRow last)
          Find a row or a list of rows that is larger and create a cursor to iterate over the result.
 Cursor Index.findNext(Session session, SearchRow higherThan, SearchRow last)
          Find a row or a list of rows that is larger and create a cursor to iterate over the result.
 Cursor MultiVersionIndex.findNext(Session session, SearchRow first, SearchRow last)
           
 Cursor PageBtreeIndex.findNext(Session session, SearchRow first, SearchRow last)
           
 Cursor PageDelegateIndex.findNext(Session session, SearchRow higherThan, SearchRow last)
           
abstract  double BaseIndex.getCost(Session session, int[] masks)
          Calculate the cost to find rows.
 double FunctionIndex.getCost(Session session, int[] masks)
           
 double HashIndex.getCost(Session session, int[] masks)
           
 double Index.getCost(Session session, int[] masks)
          Estimate the cost to search for rows given the search mask.
 double LinkedIndex.getCost(Session session, int[] masks)
           
 double MetaIndex.getCost(Session session, int[] masks)
           
 double MultiVersionIndex.getCost(Session session, int[] masks)
           
 double PageBtreeIndex.getCost(Session session, int[] masks)
           
 double PageDataIndex.getCost(Session session, int[] masks)
           
 double PageDelegateIndex.getCost(Session session, int[] masks)
           
 double RangeIndex.getCost(Session session, int[] masks)
           
 double ScanIndex.getCost(Session session, int[] masks)
           
 double TreeIndex.getCost(Session session, int[] masks)
           
 double ViewIndex.getCost(Session session, int[] masks)
           
 ResultInterface IndexCondition.getCurrentResult(Session session)
          Get the current result of the expression.
 Value IndexCondition.getCurrentValue(Session session)
          Get the current value of the expression.
 Value[] IndexCondition.getCurrentValueList(Session session)
          Get the current value list of the expression.
 Row BaseIndex.getRow(Session session, long key)
           
 Row Index.getRow(Session session, long key)
          Get the row with the given key.
 Row MultiVersionIndex.getRow(Session session, long key)
           
 Row PageBtreeIndex.getRow(Session session, long key)
          Get a row from the main index.
 Row PageDataIndex.getRow(Session session, long key)
           
 Row ScanIndex.getRow(Session session, long key)
           
 long FunctionIndex.getRowCount(Session session)
           
 long HashIndex.getRowCount(Session session)
           
 long Index.getRowCount(Session session)
          Get the row count of this table, for the given session.
 long LinkedIndex.getRowCount(Session session)
           
 long MetaIndex.getRowCount(Session session)
           
 long MultiVersionIndex.getRowCount(Session session)
           
 long NonUniqueHashIndex.getRowCount(Session session)
           
 long PageBtreeIndex.getRowCount(Session session)
           
 long PageDataIndex.getRowCount(Session session)
           
 long PageDelegateIndex.getRowCount(Session session)
           
 long RangeIndex.getRowCount(Session session)
           
 long ScanIndex.getRowCount(Session session)
           
 long TreeIndex.getRowCount(Session session)
           
 long ViewIndex.getRowCount(Session session)
           
 boolean MultiVersionIndex.isUncommittedFromOtherSession(Session session, Row row)
          Check if there is an uncommitted row with the given key within a different session.
 void PageBtreeLeaf.moveTo(Session session, int newPos)
           
 void PageBtreeNode.moveTo(Session session, int newPos)
           
 void PageDataLeaf.moveTo(Session session, int newPos)
           
 void PageDataNode.moveTo(Session session, int newPos)
           
 void PageDataOverflow.moveTo(Session session, int newPos)
           
abstract  void BaseIndex.remove(Session session)
          Remove the index.
 void FunctionIndex.remove(Session session)
           
 void HashIndex.remove(Session session)
           
 void Index.remove(Session session)
          Remove the index.
 void LinkedIndex.remove(Session session)
           
 void MetaIndex.remove(Session session)
           
 void MultiVersionIndex.remove(Session session)
           
 void PageBtreeIndex.remove(Session session)
           
 void PageDataIndex.remove(Session session)
           
 void PageDelegateIndex.remove(Session session)
           
 void RangeIndex.remove(Session session)
           
 void ScanIndex.remove(Session session)
           
 void TreeIndex.remove(Session session)
           
 void ViewIndex.remove(Session session)
           
abstract  void BaseIndex.remove(Session session, Row row)
          Remove a row from the index.
 void FunctionIndex.remove(Session session, Row row)
           
 void HashIndex.remove(Session session, Row row)
           
 void Index.remove(Session session, Row row)
          Remove a row from the index.
 void LinkedIndex.remove(Session session, Row row)
           
 void MetaIndex.remove(Session session, Row row)
           
 void MultiVersionIndex.remove(Session session, Row row)
           
 void NonUniqueHashIndex.remove(Session session, Row row)
           
 void PageBtreeIndex.remove(Session session, Row row)
           
 void PageDataIndex.remove(Session session, Row row)
           
 void PageDelegateIndex.remove(Session session, Row row)
           
 void RangeIndex.remove(Session session, Row row)
           
 void ScanIndex.remove(Session session, Row row)
           
 void TreeIndex.remove(Session session, Row row)
           
 void ViewIndex.remove(Session session, Row row)
           
 void BaseIndex.removeChildrenAndResources(Session session)
           
 void MultiVersionIndex.removeChildrenAndResources(Session session)
           
abstract  void BaseIndex.truncate(Session session)
          Truncate the index.
 void FunctionIndex.truncate(Session session)
           
 void HashIndex.truncate(Session session)
           
 void Index.truncate(Session session)
          Remove all rows from the index.
 void LinkedIndex.truncate(Session session)
           
 void MetaIndex.truncate(Session session)
           
 void MultiVersionIndex.truncate(Session session)
           
 void NonUniqueHashIndex.truncate(Session session)
           
 void PageBtreeIndex.truncate(Session session)
           
 void PageDataIndex.truncate(Session session)
           
 void PageDelegateIndex.truncate(Session session)
           
 void RangeIndex.truncate(Session session)
           
 void ScanIndex.truncate(Session session)
           
 void TreeIndex.truncate(Session session)
           
 void ViewIndex.truncate(Session session)
           
 

Constructors in org.h2.index with parameters of type Session
NonUniqueHashCursor(Session session, RegularTable tableData, java.util.ArrayList<java.lang.Long> positions)
           
PageBtreeIndex(RegularTable table, int id, java.lang.String indexName, IndexColumn[] columns, IndexType indexType, boolean create, Session session)
           
PageDataIndex(RegularTable table, int id, IndexColumn[] columns, IndexType indexType, boolean create, Session session)
           
PageDelegateIndex(RegularTable table, int id, java.lang.String name, IndexType indexType, PageDataIndex mainIndex, boolean create, Session session)
           
ViewIndex(TableView view, ViewIndex index, Session session, int[] masks)
           
 

Uses of Session in org.h2.result
 

Methods in org.h2.result with parameters of type Session
 LocalResult LocalResult.createShallowCopy(Session targetSession)
          Create a shallow copy of the result set.
static LocalResult LocalResult.read(Session session, java.sql.ResultSet rs, int maxrows)
          Construct a local result set by reading all data from a regular result set.
 

Constructors in org.h2.result with parameters of type Session
LocalResult(Session session, Expression[] expressions, int visibleColumnCount)
          Construct a local result object.
ResultTempTable(Session session, SortOrder sort)
           
RowList(Session session)
          Construct a new row list for this session.
 

Uses of Session in org.h2.schema
 

Methods in org.h2.schema with parameters of type Session
 Constraint Schema.findConstraint(Session session, java.lang.String name)
          Try to find a constraint with this name.
 Index Schema.findIndex(Session session, java.lang.String name)
          Try to find an index with this name.
 Table Schema.findTableOrView(Session session, java.lang.String name)
          Try to find a table or view with this name.
 void TriggerObject.fire(Session session, int type, boolean beforeAction)
          Call the trigger class if required.
 boolean TriggerObject.fireRow(Session session, Row oldRow, Row newRow, boolean beforeAction, boolean rollback)
          Call the fire method of the user-defined trigger class if required.
 void Sequence.flush(Session session)
          Flush the current value, including the margin, to disk.
 long Sequence.getNext(Session session)
          Get the next value for this sequence.
 Table Schema.getTableOrView(Session session, java.lang.String name)
          Get the table or view with the given name.
 java.lang.String Schema.getUniqueConstraintName(Session session, Table table)
          Create a unique constraint name.
 java.lang.String Schema.getUniqueIndexName(Session session, Table table, java.lang.String prefix)
          Create a unique index name.
 void Constant.removeChildrenAndResources(Session session)
           
 void Schema.removeChildrenAndResources(Session session)
           
 void Sequence.removeChildrenAndResources(Session session)
           
 void TriggerObject.removeChildrenAndResources(Session session)
           
 void TriggerObject.setTriggerClassName(Session session, java.lang.String triggerClassName, boolean force)
          Set the trigger class name and load the class if possible.
 

Uses of Session in org.h2.store
 

Methods in org.h2.store with parameters of type Session
 void PageStore.addMeta(PageIndex index, Session session)
          Add the meta data of an index.
 void PageStore.commit(Session session)
          Mark a committed transaction.
 void PageStore.logAddOrRemoveRow(Session session, int tableId, Row row, boolean add)
          A record is added to a table, or removed from a table.
 void PageStore.logTruncate(Session session, int tableId)
          A table is truncated.
abstract  void Page.moveTo(Session session, int newPos)
          Copy the data to a new location, change the parent to point to the new location, and free up the current page.
 void PageFreeList.moveTo(Session session, int newPos)
           
 void PageStreamData.moveTo(Session session, int newPos)
           
 void PageStreamTrunk.moveTo(Session session, int newPos)
           
 void PageStore.prepareCommit(Session session, java.lang.String transaction)
          Prepare a transaction.
 void PageStore.removeMeta(Index index, Session session)
          Remove the meta data of an index.
 

Uses of Session in org.h2.table
 

Fields in org.h2.table declared as Session
protected  Session TableFilter.session
           
 

Methods in org.h2.table that return types with arguments of type Session
 java.util.ArrayList<Session> RegularTable.checkDeadlock(Session session, Session clash, java.util.Set<Session> visited)
           
 java.util.ArrayList<Session> Table.checkDeadlock(Session session, Session clash, java.util.Set<Session> visited)
          Check if a deadlock occurred.
 

Methods in org.h2.table with parameters of type Session
 void Column.addCheckConstraint(Session session, Expression expr)
          Add a check constraint expression to this column.
 Index FunctionTable.addIndex(Session session, java.lang.String indexName, int indexId, IndexColumn[] cols, IndexType indexType, boolean create, java.lang.String indexComment)
           
 Index MetaTable.addIndex(Session session, java.lang.String indexName, int indexId, IndexColumn[] cols, IndexType indexType, boolean create, java.lang.String indexComment)
           
 Index RangeTable.addIndex(Session session, java.lang.String indexName, int indexId, IndexColumn[] cols, IndexType indexType, boolean create, java.lang.String indexComment)
           
 Index RegularTable.addIndex(Session session, java.lang.String indexName, int indexId, IndexColumn[] cols, IndexType indexType, boolean create, java.lang.String indexComment)
           
abstract  Index Table.addIndex(Session session, java.lang.String indexName, int indexId, IndexColumn[] cols, IndexType indexType, boolean create, java.lang.String indexComment)
          Create an index for this table
 Index TableLink.addIndex(Session session, java.lang.String indexName, int indexId, IndexColumn[] cols, IndexType indexType, boolean create, java.lang.String indexComment)
           
 Index TableView.addIndex(Session session, java.lang.String indexName, int indexId, IndexColumn[] cols, IndexType indexType, boolean create, java.lang.String indexComment)
           
 void FunctionTable.addRow(Session session, Row row)
           
 void MetaTable.addRow(Session session, Row row)
           
 void RangeTable.addRow(Session session, Row row)
           
 void RegularTable.addRow(Session session, Row row)
           
abstract  void Table.addRow(Session session, Row row)
          Add a row to the table and all indexes.
 void TableLink.addRow(Session session, Row row)
           
 void TableView.addRow(Session session, Row row)
           
 double Plan.calculateCost(Session session)
          Calculate the cost of this query plan.
 java.util.ArrayList<Session> RegularTable.checkDeadlock(Session session, Session clash, java.util.Set<Session> visited)
           
 java.util.ArrayList<Session> Table.checkDeadlock(Session session, Session clash, java.util.Set<Session> visited)
          Check if a deadlock occurred.
 void FunctionTable.close(Session session)
           
 void MetaTable.close(Session session)
           
 void RangeTable.close(Session session)
           
 void RegularTable.close(Session session)
           
abstract  void Table.close(Session session)
          Close the table object and flush changes.
 void TableLink.close(Session session)
           
 void TableView.close(Session session)
           
 void Column.convertAutoIncrementToSequence(Session session, Schema schema, int id, boolean temporary)
          Convert the auto-increment flag to a sequence that is linked with this table.
static TableView TableView.createTempView(Session session, User owner, java.lang.String name, Query query, Query topQuery)
          Create a temporary view out of the given query.
 void Table.fire(Session session, int type, boolean beforeAction)
          Fire the triggers for this table.
 void Table.fireAfterRow(Session session, Row oldRow, Row newRow, boolean rollback)
          Fire all triggers that need to be called after a row is updated.
 boolean Table.fireBeforeRow(Session session, Row oldRow, Row newRow)
          Fire all triggers that need to be called before a row is updated.
 java.util.ArrayList<Row> MetaTable.generateRows(Session session, SearchRow first, SearchRow last)
          Generate the data for the given metadata table using the given first and last row filters.
 PlanItem TableFilter.getBestPlanItem(Session s, int level)
          Get the best plan item (index, cost) to use use for the current join order.
 PlanItem Table.getBestPlanItem(Session session, int[] masks)
          Get the best plan for the given search mask.
 PlanItem TableView.getBestPlanItem(Session session, int[] masks)
           
 Expression Column.getCheckConstraint(Session session, java.lang.String asColumnName)
          Get the check constraint expression for this column if set.
 Value Table.getDefaultValue(Session session, Column column)
          Get or generate a default value for the given column.
 Value TableLink.getDefaultValue(Session session, Column column)
          Get or generate a default value for the given column.
 long RangeTable.getMax(Session session)
          Calculate and get the end value of this range.
 long RangeTable.getMin(Session session)
          Calculate and get the start value of this range.
 LocalResult FunctionTable.getResult(Session session)
          Read the result set from the function.
 Row RegularTable.getRow(Session session, long key)
          Read the given row.
 long FunctionTable.getRowCount(Session session)
           
 long MetaTable.getRowCount(Session session)
           
 long RangeTable.getRowCount(Session session)
           
 long RegularTable.getRowCount(Session session)
           
abstract  long Table.getRowCount(Session session)
          Get the row count for this table.
 long TableLink.getRowCount(Session session)
           
 long TableView.getRowCount(Session session)
           
 Index FunctionTable.getScanIndex(Session session)
           
 Index MetaTable.getScanIndex(Session session)
           
 Index RangeTable.getScanIndex(Session session)
           
 Index RegularTable.getScanIndex(Session session)
           
abstract  Index Table.getScanIndex(Session session)
          Get the scan index to iterate through all rows.
 Index TableLink.getScanIndex(Session session)
           
 Index TableView.getScanIndex(Session session)
           
 boolean RegularTable.isLockedExclusivelyBy(Session session)
           
 boolean Table.isLockedExclusivelyBy(Session session)
          Check if the table is exclusively locked by this session.
 void FunctionTable.lock(Session session, boolean exclusive, boolean force)
           
 void MetaTable.lock(Session session, boolean exclusive, boolean force)
           
 void RangeTable.lock(Session session, boolean exclusive, boolean force)
           
 void RegularTable.lock(Session session, boolean exclusive, boolean force)
           
abstract  void Table.lock(Session session, boolean exclusive, boolean force)
          Lock the table for the given session.
 void TableFilter.lock(Session s, boolean exclusive, boolean force)
          Lock the table.
 void TableLink.lock(Session session, boolean exclusive, boolean force)
           
 void TableView.lock(Session session, boolean exclusive, boolean force)
           
 void Column.prepareExpression(Session session)
          Prepare all expressions of this column.
 void TableView.recompile(Session session)
          Re-compile the view query.
 Query TableView.recompileQuery(Session session)
          Re-compile the query, updating the SQL statement.
 void MetaTable.removeChildrenAndResources(Session session)
           
 void RegularTable.removeChildrenAndResources(Session session)
           
 void Table.removeChildrenAndResources(Session session)
           
 void TableLink.removeChildrenAndResources(Session session)
           
 void TableView.removeChildrenAndResources(Session session)
           
 void Table.removeIndexOrTransferOwnership(Session session, Index index)
          If the index is still required by a constraint, transfer the ownership to it.
 void FunctionTable.removeRow(Session session, Row row)
           
 void MetaTable.removeRow(Session session, Row row)
           
 void RangeTable.removeRow(Session session, Row row)
           
 void RegularTable.removeRow(Session session, Row row)
           
abstract  void Table.removeRow(Session session, Row row)
          Remove a row from the table and all indexes.
 void TableLink.removeRow(Session session, Row row)
           
 void TableView.removeRow(Session session, Row row)
           
 void Table.removeSequence(Session session, Sequence sequence)
          Remove a sequence from the table.
 void Table.setCheckForeignKeyConstraints(Session session, boolean enabled, boolean checkExisting)
          Enable or disable foreign key constraint checking for this table.
 void Column.setDefaultExpression(Session session, Expression defaultExpression)
          Set the default expression.
 void TableFilter.startQuery(Session s)
          Start the query.
 void FunctionTable.truncate(Session session)
           
 void MetaTable.truncate(Session session)
           
 void RangeTable.truncate(Session session)
           
 void RegularTable.truncate(Session session)
           
abstract  void Table.truncate(Session session)
          Remove all rows from the table and indexes.
 void TableLink.truncate(Session session)
           
 void TableView.truncate(Session session)
           
 void FunctionTable.unlock(Session s)
           
 void MetaTable.unlock(Session s)
           
 void RangeTable.unlock(Session s)
           
 void RegularTable.unlock(Session s)
           
abstract  void Table.unlock(Session s)
          Release the lock for this session.
 void TableLink.unlock(Session s)
           
 void TableView.unlock(Session s)
           
 void Table.updateRows(Prepared prepared, Session session, RowList rows)
          Update a list of rows in this table.
 void TableLink.updateRows(Prepared prepared, Session session, RowList rows)
           
 void Table.validateConvertUpdateSequence(Session session, Row row)
          Validate all values in this row, convert the values if required, and update the sequence values if required.
 void TableLink.validateConvertUpdateSequence(Session session, Row row)
          Convert the values if required.
 Value Column.validateConvertUpdateSequence(Session session, Value value)
          Validate the value, convert it if required, and update the sequence value if required.
 

Method parameters in org.h2.table with type arguments of type Session
 java.util.ArrayList<Session> RegularTable.checkDeadlock(Session session, Session clash, java.util.Set<Session> visited)
           
 java.util.ArrayList<Session> Table.checkDeadlock(Session session, Session clash, java.util.Set<Session> visited)
          Check if a deadlock occurred.
 

Constructors in org.h2.table with parameters of type Session
FunctionTable(Schema schema, Session session, Expression functionExpr, FunctionCall function)
           
TableFilter(Session session, Table table, java.lang.String alias, boolean rightsChecked, Select select)
          Create a new table filter object.
TableView(Schema schema, int id, java.lang.String name, java.lang.String querySQL, java.util.ArrayList<Parameter> params, java.lang.String[] columnNames, Session session, boolean recursive)