|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
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()
|
ObjectArray<Expression> |
Select.getExpressions()
|
ObjectArray<Expression> |
SelectUnion.getExpressions()
|
abstract ObjectArray<Expression> |
Query.getExpressions()
The the list of select expressions. |
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 |
Merge.addRow(Expression[] expr)
Add a row to this merge statement. |
void |
Insert.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 |
Update.setCondition(Expression condition)
|
void |
Delete.setCondition(Expression condition)
|
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)
|
void |
Call.setValue(Expression expression)
|
Method parameters in org.h2.command.dml with type arguments of type Expression | |
---|---|
void |
Select.setExpressions(ObjectArray<Expression> expressions)
|
void |
Select.setGroupBy(ObjectArray<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[] |
FunctionCall.getArgs()
Get the function arguments. |
Expression[] |
JavaFunction.getArgs()
|
Expression[] |
Function.getArgs()
|
Expression |
ConditionAndOr.getExpression(boolean getLeft)
Get the left or the right sub-expression of this condition. |
Expression |
Comparison.getExpression(boolean getLeft)
Get the left or the right sub-expression of this condition. |
Expression |
Alias.getNonAliasExpression()
|
Expression |
Expression.getNonAliasExpression()
Returns the main expression, skipping aliases. |
Expression |
ConditionAndOr.getNotIfPossible(Session session)
|
Expression |
ExpressionColumn.getNotIfPossible(Session session)
|
Expression |
Parameter.getNotIfPossible(Session session)
|
Expression |
ConditionNot.getNotIfPossible(Session session)
|
Expression |
Expression.getNotIfPossible(Session session)
If it is possible, return the negated expression. |
Expression |
ValueExpression.getNotIfPossible(Session session)
|
Expression |
Comparison.getNotIfPossible(Session session)
|
Expression |
ConditionAndOr.optimize(Session session)
|
Expression |
ConditionInSelect.optimize(Session session)
|
Expression |
ExpressionColumn.optimize(Session session)
|
Expression |
Parameter.optimize(Session session)
|
Expression |
FunctionCall.optimize(Session session)
Optimize the function if possible. |
Expression |
Variable.optimize(Session session)
|
Expression |
Alias.optimize(Session session)
|
Expression |
Wildcard.optimize(Session session)
|
Expression |
Rownum.optimize(Session session)
|
Expression |
ConditionNot.optimize(Session session)
|
Expression |
SequenceValue.optimize(Session session)
|
abstract Expression |
Expression.optimize(Session session)
Try to optimize the expression. |
Expression |
CompareLike.optimize(Session session)
|
Expression |
JavaFunction.optimize(Session session)
|
Expression |
ValueExpression.optimize(Session session)
|
Expression |
Comparison.optimize(Session session)
|
Expression |
Operation.optimize(Session session)
|
Expression |
ExpressionList.optimize(Session session)
|
Expression |
ConditionExists.optimize(Session session)
|
Expression |
JavaAggregate.optimize(Session session)
|
Expression |
Aggregate.optimize(Session session)
|
Expression |
Function.optimize(Session session)
|
Expression |
ConditionIn.optimize(Session session)
|
Expression |
Subquery.optimize(Session session)
|
Expression |
ConditionAndOr.optimizeInJoin(Session session,
Select select)
|
Expression |
ConditionInSelect.optimizeInJoin(Session session,
Select select)
|
Expression |
Expression.optimizeInJoin(Session session,
Select select)
Optimize IN(...) expressions if possible. |
Expression |
ConditionIn.optimizeInJoin(Session session,
Select select)
|
Methods in org.h2.expression with parameters of type Expression | |
---|---|
ValueResultSet |
FunctionCall.getValueForColumnList(Session session,
Expression[] nullArgs)
Get an empty result set with the column names set. |
ValueResultSet |
JavaFunction.getValueForColumnList(Session session,
Expression[] args)
|
ValueResultSet |
TableFunction.getValueForColumnList(Session session,
Expression[] nullArgs)
|
ValueResultSet |
Function.getValueForColumnList(Session session,
Expression[] args)
|
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,
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,
ObjectArray<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,
ObjectArray<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,
ObjectArray<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. |
Constructor parameters in org.h2.result with type arguments of type Expression | |
---|---|
LocalResult(Session session,
ObjectArray<Expression> expressionList,
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 |
TableFilter.optimize(ExpressionColumn expressionColumn,
Column column)
|
Expression |
ColumnResolver.optimize(ExpressionColumn expressionColumn,
Column column)
Get the expression that represents this column. |
Expression |
SingleColumnResolver.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 join)
Add a filter condition. |
void |
TableFilter.addJoin(TableFilter filter,
boolean outer,
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)
Create a new range with the given start and end expressions. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |