Uses of Class
org.h2.expression.Expression

Packages that use Expression
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.table Classes related to a table and table meta data. 
 

Uses of Expression in org.h2.command
 

Methods in org.h2.command that return Expression
 Expression Parser.parseExpression(java.lang.String sql)
          Parse a SQL code snippet that represents an expression.
 

Methods in org.h2.command with parameters of type Expression
protected  java.lang.String Prepared.getSQL(Expression[] list)
          Get the SQL snippet of the expression list.
 

Uses of Expression in org.h2.command.ddl
 

Methods in org.h2.command.ddl with parameters of type Expression
 void CreateSequence.setCacheSize(Expression cacheSize)
           
 void AlterTableAddConstraint.setCheckExpression(Expression expression)
           
 void SetComment.setCommentExpression(Expression expr)
           
 void AlterTableAlterColumn.setDefaultExpression(Expression defaultExpression)
           
 void CreateConstant.setExpression(Expression expr)
           
 void AlterUser.setHash(Expression e)
           
 void CreateUser.setHash(Expression e)
           
 void CreateSequence.setIncrement(Expression increment)
           
 void AlterUser.setPassword(Expression password)
           
 void CreateUser.setPassword(Expression password)
           
 void AlterUser.setSalt(Expression e)
           
 void CreateUser.setSalt(Expression e)
           
 void AlterTableAlterColumn.setSelectivity(Expression selectivity)
           
 void CreateSequence.setStartWith(Expression start)
           
 

Uses of Expression in org.h2.command.dml
 

Fields in org.h2.command.dml declared as Expression
 Expression SelectOrderBy.columnIndexExpr
          The column index expression.
 Expression SelectOrderBy.expression
          The order by expression.
protected  Expression Query.limitExpr
          The limit expression as specified in the LIMIT or TOP clause.
protected  Expression Query.offsetExpr
          The offset expression as specified in the LIMIT ..
 

Methods in org.h2.command.dml that return Expression
 Expression SelectListColumnResolver.optimize(ExpressionColumn expressionColumn, Column column)
           
 

Methods in org.h2.command.dml that return types with arguments of type Expression
 java.util.HashMap<Expression,java.lang.Object> Select.getCurrentGroup()
           
abstract  java.util.ArrayList<Expression> Query.getExpressions()
          The the list of select expressions.
 java.util.ArrayList<Expression> Select.getExpressions()
           
 java.util.ArrayList<Expression> SelectUnion.getExpressions()
           
 

Methods in org.h2.command.dml with parameters of type Expression
 void Select.addCondition(Expression cond)
          Add a condition to the list of conditions.
 void Insert.addRow(Expression[] expr)
          Add a row to this merge statement.
 void Merge.addRow(Expression[] expr)
          Add a row to this merge statement.
 void Update.setAssignment(Column column, Expression expression)
          Add an assignment of the form column = expression.
 void Delete.setCondition(Expression condition)
           
 void Update.setCondition(Expression condition)
           
 void Call.setExpression(Expression expression)
           
 void Set.setExpression(Expression expression)
           
 void ExecuteProcedure.setExpression(int index, Expression expr)
          Set the expression at the given index.
 void BackupCommand.setFileName(Expression fileName)
           
 void ScriptBase.setFileNameExpr(Expression file)
           
 void Select.setHaving(Expression having)
           
 void AlterSequence.setIncrement(Expression increment)
           
 void Query.setLimit(Expression limit)
           
 void Query.setOffset(Expression offset)
           
 void AlterSequence.setStartWith(Expression start)
           
 

Method parameters in org.h2.command.dml with type arguments of type Expression
 void Select.setExpressions(java.util.ArrayList<Expression> expressions)
           
 void Select.setGroupBy(java.util.ArrayList<Expression> group)
           
 

Uses of Expression in org.h2.constraint
 

Methods in org.h2.constraint that return Expression
 Expression ConstraintCheck.getExpression()
           
 

Methods in org.h2.constraint with parameters of type Expression
 void ConstraintCheck.setExpression(Expression expr)
           
 

Uses of Expression in org.h2.engine
 

Methods in org.h2.engine with parameters of type Expression
 FunctionAlias.JavaMethod FunctionAlias.findJavaMethod(Expression[] args)
          Find the Java method that matches the arguments.
 Value FunctionAlias.JavaMethod.getValue(Session session, Expression[] args, boolean columnList)
          Call the user-defined function and return the value.
 

Uses of Expression in org.h2.expression
 

Subclasses of Expression in org.h2.expression
 class Aggregate
          Implements the integrated aggregate functions, such as COUNT, MAX, SUM.
 class Alias
          A column alias as in SELECT 'Hello' AS NAME ...
 class CompareLike
          Pattern matching comparison expression: WHERE NAME LIKE ?
 class Comparison
          Example comparison expressions are ID=1, NAME=NAME, NAME IS NULL.
 class Condition
          Represents a condition returning a boolean value, or NULL.
 class ConditionAndOr
          An 'and' or 'or' condition as in WHERE ID=1 AND NAME=?
 class ConditionExists
          An 'exists' condition as in WHERE EXISTS(SELECT ...)
 class ConditionIn
          An 'in' condition with a list of values, as in WHERE NAME IN(...)
 class ConditionInSelect
          An 'in' condition with a subquery, as in WHERE ID IN(SELECT ...)
 class ConditionNot
          A NOT condition.
 class ExpressionColumn
          A expression that represents a column of a table or view.
 class ExpressionList
          A list of expressions, as in (ID, NAME).
 class Function
          This class implements most built-in functions of this database.
 class JavaAggregate
          This class wraps a user-defined aggregate.
 class JavaFunction
          This class wraps a user-defined function.
 class Operation
          A mathematical expression, or string concatenation.
 class Parameter
          A parameter of a prepared statement.
 class Rownum
          Represents the ROWNUM function.
 class SequenceValue
          Wraps a sequence when used in a statement.
 class Subquery
          A query returning a single value.
 class TableFunction
          Implementation of the functions TABLE(..) and TABLE_DISTINCT(..).
 class ValueExpression
          An expression representing a constant value.
 class Variable
          A user-defined variable, for example: @ID.
 class Wildcard
          A wildcard expression as in SELECT * FROM TEST.
 

Fields in org.h2.expression declared as Expression
protected  Expression[] Function.args
           
 

Methods in org.h2.expression that return Expression
 Expression ConditionIn.getAdditional(Session session, Comparison other)
          Add an additional element if possible.
 Expression[] Function.getArgs()
           
 Expression[] FunctionCall.getArgs()
          Get the function arguments.
 Expression[] JavaFunction.getArgs()
           
 Expression Comparison.getExpression(boolean getLeft)
          Get the left or the right sub-expression of this condition.
 Expression ConditionAndOr.getExpression(boolean getLeft)
          Get the left or the right sub-expression of this condition.
 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 Alias.getNonAliasExpression()
           
 Expression Expression.getNonAliasExpression()
          Returns the main expression, skipping aliases.
 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)
           
 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)
           
 

Methods in org.h2.expression with parameters of type Expression
 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)
           
 void Function.setParameter(int index, Expression param)
          Set the parameter expression at the given index.
 void Aggregate.setSeparator(Expression separator)
          Set the separator for GROUP_CONCAT.
 

Constructors in org.h2.expression with parameters of type Expression
Aggregate(int type, Expression on, Select select, boolean distinct)
          Create a new aggregate object.
Alias(Expression expression, java.lang.String alias, boolean aliasColumnName)
           
CompareLike(CompareMode compareMode, java.lang.String defaultEscape, Expression left, Expression right, Expression escape, boolean regexp)
           
CompareLike(Database db, Expression left, Expression right, Expression escape, boolean regexp)
           
Comparison(Session session, int compareType, Expression left, Expression right)
           
ConditionAndOr(int andOrType, Expression left, Expression right)
           
ConditionIn(Database database, Expression left, java.util.ArrayList<Expression> values)
          Create a new IN(..) condition.
ConditionInSelect(Database database, Expression left, Query query, boolean all, int compareType)
           
ConditionNot(Expression condition)
           
ExpressionList(Expression[] list)
           
JavaAggregate(UserAggregate userAggregate, Expression[] args, Select select)
           
JavaFunction(FunctionAlias functionAlias, Expression[] args)
           
Operation(int opType, Expression left, Expression right)
           
 

Constructor parameters in org.h2.expression with type arguments of type Expression
ConditionIn(Database database, Expression left, java.util.ArrayList<Expression> values)
          Create a new IN(..) condition.
 

Uses of Expression in org.h2.index
 

Methods in org.h2.index with parameters of type Expression
static IndexCondition IndexCondition.get(int compareType, ExpressionColumn column, Expression expression)
          Create an index condition with the given parameters.
 

Method parameters in org.h2.index with type arguments of type Expression
static IndexCondition IndexCondition.getInList(ExpressionColumn column, java.util.List<Expression> list)
          Create an index condition with the compare type IN_LIST and with the given parameters.
 

Uses of Expression in org.h2.result
 

Methods in org.h2.result with parameters of type Expression
 java.lang.String SortOrder.getSQL(Expression[] list, int visible)
          Create the SQL snippet that describes this sort order.
 

Constructors in org.h2.result with parameters of type Expression
LocalResult(Session session, Expression[] expressions, int visibleColumnCount)
          Construct a local result object.
 

Uses of Expression in org.h2.table
 

Methods in org.h2.table that return Expression
 Expression Column.getCheckConstraint(Session session, java.lang.String asColumnName)
          Get the check constraint expression for this column if set.
 Expression Column.getDefaultExpression()
           
 Expression TableFilter.getFilterCondition()
           
 Expression TableFilter.getJoinCondition()
           
 Expression ColumnResolver.optimize(ExpressionColumn expressionColumn, Column column)
          Get the expression that represents this column.
 Expression SingleColumnResolver.optimize(ExpressionColumn expressionColumn, Column col)
           
 Expression TableFilter.optimize(ExpressionColumn expressionColumn, Column column)
           
 

Methods in org.h2.table with parameters of type Expression
 void Column.addCheckConstraint(Session session, Expression expr)
          Add a check constraint expression to this column.
 void TableFilter.addFilterCondition(Expression condition, boolean isJoin)
          Add a filter condition.
 void TableFilter.addJoin(TableFilter filter, boolean outer, boolean nested, Expression on)
          Add a joined table.
 void TableFilter.mapAndAddFilter(Expression on)
          Map the columns and add the join condition.
 void Column.setComputedExpression(Expression expression)
          Set the default value in the form of a computed expression of other columns.
 void Column.setDefaultExpression(Session session, Expression defaultExpression)
          Set the default expression.
 void TableFilter.setFullCondition(Expression condition)
           
 

Constructors in org.h2.table with parameters of type Expression
FunctionTable(Schema schema, Session session, Expression functionExpr, FunctionCall function)
           
Plan(TableFilter[] filters, int count, Expression condition)
          Create a query plan with the given order.
RangeTable(Schema schema, Expression min, Expression max, boolean noColumns)
          Create a new range with the given start and end expressions.