Uses of Interface
org.eclipse.persistence.jpa.jpql.parser.Expression

Packages that use Expression

Package	Description
org.eclipse.persistence.jpa.jpql	This package contains the Hermes features (except the parser itself): semantic and grammatical validations, content assist support, calculating the query result type or the possible type of an input parameter, refactoring tools.
org.eclipse.persistence.jpa.jpql.parser	This is the core of Hermes, this package contains the classes that can parse a JPQL query.
org.eclipse.persistence.jpa.jpql.tools
org.eclipse.persistence.jpa.jpql.tools.model	The classes defined in this package define the state model API, a state model can be used to manually or programmatically create and edit a JPQL query.
org.eclipse.persistence.jpa.jpql.tools.model.query	This package contains the StateObject classes that represents a JPQL query.
org.eclipse.persistence.jpa.jpql.tools.resolver

Uses of Expression in org.eclipse.persistence.jpa.jpql

Fields in org.eclipse.persistence.jpa.jpql declared as Expression

Modifier and Type	Field	Description
protected Expression	AbstractEclipseLinkSemanticValidator.TableExpressionVisitor.expression	The Expression being visited.
protected Expression	ParameterTypeVisitor.expression	The Expression that will help to determine the type of the input parameter.

Fields in org.eclipse.persistence.jpa.jpql with type parameters of type Expression

Modifier and Type	Field	Description
protected List<Expression>	AbstractValidator.ChildrenCollectorVisitor.expressions	The unique Expression that was visited or the children of CollectionExpression.
protected final Set<Expression>	ParameterTypeVisitor.visitedExpressions	This is used to prevent an infinite loop.

Methods in org.eclipse.persistence.jpa.jpql that return Expression

Modifier and Type	Method	Description
Expression	JPQLQueryDeclaration.getBaseExpression()	Returns the range variable declaration if this is a range declaration otherwise the collection-valued path expression when this is a collection member declaration.
Expression	JPQLQueryDeclaration.getDeclarationExpression()	Returns the declaration expression, which is either an IdentificationVariableDeclaration or a CollectionMemberDeclaration when part of a FROM clause, otherwise it's either the DeleteClause or the UpdateClause.
Expression	JPQLQueryProblem.getExpression()	Returns the parsed tree representing the JPQL query.

Methods in org.eclipse.persistence.jpa.jpql that return types with arguments of type Expression

Modifier and Type	Method	Description
protected List<Expression>	AbstractValidator.getChildren(Expression expression)	Returns a list containing either the given Expression if it's not a CollectionExpression or the children of the given CollectionExpression.

Methods in org.eclipse.persistence.jpa.jpql with parameters of type Expression

Modifier and Type	Method	Description
protected void	AbstractValidator.addProblem(Expression expression, int startPosition, int endPosition, String messageKey, String... messageArguments)	Adds a new validation problem that was found in the given Expression.
protected void	AbstractValidator.addProblem(Expression expression, int startPosition, String messageKey, String... messageArguments)	Adds a new validation problem that was found in the given Expression.
protected void	AbstractValidator.addProblem(Expression expression, String messageKey)	Adds a new validation problem that was found in the given Expression.
protected void	AbstractValidator.addProblem(Expression expression, String messageKey, String... arguments)	Adds a new validation problem that was found in the given Expression.
protected JPQLQueryProblem	AbstractValidator.buildProblem(Expression expression, int startPosition, int endPosition, String messageKey, String... messageArguments)	Creates a new validation problem that was found in the given Expression.
protected List<Expression>	AbstractValidator.getChildren(Expression expression)	Returns a list containing either the given Expression if it's not a CollectionExpression or the children of the given CollectionExpression.
protected CollectionExpression	AbstractGrammarValidator.getCollectionExpression(Expression expression)	Casts the given Expression to a CollectionExpression if it is actually an object of that type.
protected CollectionValuedPathExpression	AbstractSemanticValidator.getCollectionValuedPathExpression(Expression expression)
Object	SemanticValidatorHelper.getManagedType(Expression expression)	Returns the managed type by resolving the given Expression.
protected StateFieldPathExpression	AbstractSemanticValidator.getStateFieldPathExpression(Expression expression)
Object	SemanticValidatorHelper.getType(Expression expression)	Returns the type by resolving the given Expression.
Object	SemanticValidatorHelper.getTypeDeclaration(Expression expression)	Returns the type declaration for the given Expression's type.
protected boolean	AbstractGrammarValidator.isCollectionExpression(Expression expression)	Determines whether the given Expression is a CollectionExpression.
protected boolean	AbstractGrammarValidator.isDateTimeConstant(Expression leftExpression)	Determines whether the given Expression represents one of the three date constants or not.
protected boolean	AbstractValidator.isNestedArray(Expression expression)	Determines whether the given Expression represents a nested array or not.
protected boolean	AbstractGrammarValidator.isOwnedByConditionalClause(Expression expression)	Determines whether the given Expression is a child of the WHERE or HAVING clause of the top-level query.
protected boolean	AbstractGrammarValidator.isOwnedByFromClause(Expression expression)	Determines whether the given Expression is a child of the FROM clause of the top-level query.
protected boolean	EclipseLinkGrammarValidator.isOwnedByInExpression(Expression expression)
protected boolean	AbstractGrammarValidator.isOwnedBySubFromClause(Expression expression)	Determines whether the given Expression is a child of the FROM clause of a subquery.
protected boolean	EclipseLinkGrammarValidator.isOwnedByUnionClause(Expression expression)	Determines whether the given Expression is a child of the UNION clause.
protected boolean	AbstractValidator.isSubquery(Expression expression)	Determines whether the given Expression is a subquery.
protected boolean	AbstractEclipseLinkSemanticValidator.isTableExpression(Expression expression)
protected boolean	AbstractValidator.isValid(Expression expression, String queryBNFId)	Determines whether the given Expression is valid by checking its JPQLQueryBNF with the JPQLQueryBNF associated with the given unique identifier.
protected boolean	AbstractValidator.isValid(Expression expression, String... queryBNFIds)	Determines whether the given Expression is valid by checking its JPQLQueryBNF with the list of JPQLQueryBNF associated with the given unique identifiers.
protected boolean	AbstractValidator.isValid(Expression expression, JPQLQueryBNF queryBNF)	Determines whether the given Expression is valid by checking its JPQLQueryBNF with the given JPQLQueryBNF.
protected boolean	AbstractValidator.isValidWithChildCollectionBypass(Expression expression, String queryBNF)	Determines whether the given Expression part is an expression of the given query BNF.
protected boolean	AbstractValidator.isWithinSubquery(Expression expression)	Determines whether the given Expression is part of a subquery.
protected boolean	AbstractValidator.isWithinTopLevelQuery(Expression expression)	Determines whether the given Expression is part of the top-level query.
protected int	AbstractValidator.length(Expression expression)	Returns the length of the string representation of the given Expression.
protected String	AbstractValidator.literal(Expression expression, LiteralType type)	Retrieves the "literal" from the given Expression.
protected int	AbstractValidator.nestedArraySize(Expression expression)	Returns the number of items in the nested array if the given Expression represents one.
protected int	AbstractGrammarValidator.position(Expression expression, int... extras)
protected int	AbstractValidator.position(Expression expression)	Calculates the position of the given expression by calculating the length of what is before.
Object	SemanticValidatorHelper.resolveMapping(Expression expression)	Returns the mapping for the field represented by the given Expression.
protected int	AbstractEclipseLinkSemanticValidator.subquerySelectItemCount(Expression subquery)	Retrieves the number of select items the given subquery has.
protected void	AbstractGrammarValidator.validateCollectionSeparatedByComma(Expression expression, String endsWithCommaProblemKey, String missingCommaProblemKey)	Validates the given Expression by making sure each child is separated by a comma.
protected void	AbstractGrammarValidator.validateCollectionSeparatedBySpace(Expression expression, String endsWithCommaProblemKey, String hasCommaProblemKey)	Validates the given Expression by making sure each child is separated by a whitespace.
protected boolean	AbstractSemanticValidator.validateCollectionValuedPathExpression(Expression expression, boolean collectionTypeOnly)	Validates the given Expression and makes sure it's a valid collection value path expression.
protected void	AbstractGrammarValidator.validateIdentifier(Expression expression, String variableName, int variableLength, String reservedWordProblemKey, String invalidJavaIdentifierProblemKey)	Validates the given variable name to make sure: It is not a JPQL reserved identifier; It is a valid Java identifier.
protected boolean	AbstractSemanticValidator.validateJoinCollectionValuedPathExpression(Expression expression, boolean collectionTypeOnly)	Validates the given Expression and makes sure it's a valid collection value path expression.
protected void	AbstractEclipseLinkSemanticValidator.SubquerySelectItemCalculator.visit(Expression expression)
protected void	AbstractSemanticValidator.ComparisonExpressionVisitor.visit(Expression expression)
protected void	AbstractSemanticValidator.FirstDeclarationVisitor.visit(Expression expression)
protected void	AbstractSemanticValidator.InItemsVisitor.visit(Expression expression)
protected void	AbstractValidator.BypassChildCollectionExpressionVisitor.visit(Expression expression)
protected void	AbstractValidator.BypassParentSubExpressionVisitor.visit(Expression expression)
protected void	AbstractValidator.ChildrenCollectorVisitor.visit(Expression expression)
protected void	AbstractValidator.JPQLQueryBNFValidator.visit(Expression expression)
protected void	AbstractValidator.visit(Expression expression)
protected void	ParameterTypeVisitor.visitDoubleExpressions(Expression expression, Expression firstExpression, Expression secondExpression, boolean traverseParent)

Uses of Expression in org.eclipse.persistence.jpa.jpql.parser

Classes in org.eclipse.persistence.jpa.jpql.parser that implement Expression

Modifier and Type	Class	Description
final class	AbsExpression	The ABS function removes the minus sign from a specified argument and returns the absolute value, which is always a positive number or zero.
class	AbstractConditionalClause	Conditional expressions are composed of other conditional expressions, comparison operations, logical operations, path expressions that evaluate to boolean values, boolean literals, and boolean input parameters.
class	AbstractDoubleEncapsulatedExpression	This Expression takes care of parsing an expression that encapsulates two expressions separated by a comma.
class	AbstractEncapsulatedExpression	This expression handles parsing the identifier followed by an expression encapsulated within parenthesis.
class	AbstractExpression	This is the abstract definition of all the parts used to create the tree hierarchy representing the parsed JPQL query.
class	AbstractFromClause	The FROM clause of a query defines the domain of the query by declaring identification variables.
class	AbstractOrderByClause	An ordering clause allows the objects or values that are returned by the query to be ordered.
class	AbstractPathExpression	An identification variable followed by the navigation operator (.) and a state field or association field is a path expression.
final class	AbstractSchemaName	An abstract schema name designates the abstract schema type over which the query ranges.
class	AbstractSelectClause	The SELECT clause denotes the query result.
class	AbstractSelectStatement	A query is an operation that retrieves data from one or more tables or views.
class	AbstractSingleEncapsulatedExpression	This expression handles parsing a JPQL identifier followed by an expression encapsulated within parenthesis.
class	AbstractTripleEncapsulatedExpression	This Expression takes care of parsing an expression that encapsulates three expressions separated by a comma.
final class	AdditionExpression	One of the four binary operators.
class	AggregateFunction	In the SELECT clause the result of a query may be the result of an aggregate function applied to a path expression.
final class	AllOrAnyExpression	An ALL conditional expression is a predicate that is true if the comparison operation is true for all values in the result of the subquery or the result of the subquery is empty.
final class	AndExpression	The AND logical operator chains multiple criteria together.
class	ArithmeticExpression	This expression represents an arithmetic expression, which means the first and second expressions are aggregated with an arithmetic sign.
final class	ArithmeticFactor	This expression simply adds a plus or minus sign to the arithmetic primary expression.
final class	AsOfClause	An AS OF clause is part of a flashback query, which provides ways to view past states of database objects, or to return database objects to a previous state, without using traditional point-in-time recovery.
final class	AvgFunction	One of the aggregate functions.
final class	BadExpression	This wraps another Expression that was correctly parsed by it is located in an invalid location within the JPQL query.
final class	BetweenExpression	Used in conditional expression to determine whether the result of an expression falls within an inclusive range of values.
final class	CaseExpression	BNF: general_case_expression ::= CASE when_clause {when_clause}* ELSE scalar_expression END or BNF: simple_case_expression ::= CASE case_operand simple_when_clause {simple_when_clause}* ELSE scalar_expression END
final class	CastExpression	The CAST function cast value to a different type.
final class	CoalesceExpression	A COALESCE expression returns null if all its arguments evaluate to null, and the value of the first non-null argument otherwise.
final class	CollectionExpression	A CollectionExpression wraps many expression which they are separated by spaces and/or commas.
final class	CollectionMemberDeclaration	An identification variable declared by a collection member declaration ranges over values of a collection obtained by navigation using a path expression.
final class	CollectionMemberExpression	This expression tests whether the designated value is a member of the collection specified by the collection-valued path expression.
final class	CollectionValuedPathExpression	A collection_valued_field is designated by the name of an association field in a one-to-many or a many-to-many relationship or by the name of an element collection field.
final class	ComparisonExpression	Only the values of like types are permitted to be compared.
class	CompoundExpression	A compound expression has a left and right expressions combined by an identifier.
final class	ConcatExpression	The CONCAT function returns a string that is a concatenation of its arguments.
final class	ConnectByClause	The CONNECT BY clause allows selecting rows in a hierarchical order using the hierarchical query clause.
final class	ConstructorExpression	In the SELECT clause a constructor may be used in the SELECT list to return one or more Java instances.
final class	CountFunction	One of the aggregate functions.
final class	DatabaseType	This expression represents the database specific data type, which may include size and scale.
final class	DateTime	This Expression represents a date or time.
final class	DefaultStringExpression	An implementation of an Expression that wraps a string.
final class	DeleteClause	This is the delete clause of the delete statement.
final class	DeleteStatement	Bulk delete operation apply to entities of a single entity class (together with its subclasses, if any).
final class	DivisionExpression	One of the four binary operators.
final class	EmptyCollectionComparisonExpression	This expression tests whether or not the collection designated by the collection-valued path expression is empty (i.e, has no elements).
class	EncapsulatedIdentificationVariableExpression	This Expression represents an identification variable that maps a Map property, either the key, the value or a Map.Entry).
final class	EntityTypeLiteral	This Expression wraps the name of an entity type.
final class	EntryExpression	An identification variable qualified by the ENTRY operator is a path expression.
final class	ExistsExpression	An EXISTS expression is a predicate that is true only if the result of the subquery consists of one or more values and that is false otherwise.
final class	ExtractExpression	The EXTRACT function extracts a date part from a date/time value.
final class	FromClause	The FROM clause of a query defines the domain of the query by declaring identification variables.
final class	FunctionExpression	This expression adds support to call native database functions.
final class	GroupByClause	The GROUP BY construct enables the aggregation of values according to the properties of an entity class.
final class	HavingClause	The HAVING construct enables conditions to be specified that further restrict the query result as restrictions upon the groups.
final class	HierarchicalQueryClause	If a table contains hierarchical data, then rows can be selected in a hierarchical order using the hierarchical query clause.
final class	IdentificationVariable	An identification variable is a valid identifier declared in the FROM clause of a query.
final class	IdentificationVariableDeclaration	An identification variable is a valid identifier declared in the FROM clause of a query.
final class	IndexExpression	The INDEX function returns an integer value corresponding to the position of its argument in an ordered list.
final class	InExpression	The state field path expression must have a string, numeric, or enum value.
final class	InputParameter	Either positional or named parameters may be used.
final class	Join	A JOIN enables the fetching of an association as a side effect of the execution of a query.
final class	JPQLExpression	A JPQLExpression is the root of the parsed tree representation of a JPQL query.
final class	KeyExpression	An identification variable qualified by the KEY operator is a path expression.
final class	KeywordExpression	The expression representing some keywords: TRUE, FALSE or NULL.
final class	LengthExpression	The LENGTH function returns the length of the string in characters as an integer.
final class	LikeExpression	The LIKE condition is used to specify a search for a pattern.
class	LocalDateTime	The DATE | TIME | DATETIME argument of LOCAL local_datetime_type expression.
class	LocalExpression	The LOCAL local_datetime_type expression.
final class	LocateExpression	The LOCATE function returns the position of a given string within a string, starting the search at a specified position.
class	LogicalExpression	This expression represents a logical expression, which means the first and second expressions are aggregated with either AND or OR.
final class	LowerExpression	The LOWER function converts a string to lower case and it returns a string.
class	MathDoubleExpression	Math double argument functions expressions.
static final class	MathDoubleExpression.Power	The POWER function takes two numeric arguments and returns a double.
static final class	MathDoubleExpression.Round	The ROUND function takes numeric argument and an integer argument and returns a number of the same type as the first argument.
class	MathSingleExpression	Math single argument functions expressions.
static final class	MathSingleExpression.Ceiling	The CEILING function takes a numeric argument and return a number (integer, float, or double) of the same type as the argument.
static final class	MathSingleExpression.Exp	The EXP function takes a numeric argument and returns a double.
static final class	MathSingleExpression.Floor	The FLOOR function takes a numeric argument and returns a number (integer, float, or double) of the same type as the argument.
static final class	MathSingleExpression.Ln	The LN function takes a numeric argument and returns a double.
static final class	MathSingleExpression.Sign	The SIGN function takes a numeric argument and returns an integer.
final class	MaxFunction	One of the aggregate functions.
final class	MinFunction	One of the aggregate functions.
final class	ModExpression	The modulo operation finds the remainder of division of one number by another.
final class	MultiplicationExpression	One of the four binary operators.
final class	NotExpression	BNF: expression ::= NOT conditional_primary
final class	NullComparisonExpression	A null comparison tests whether or not the single-valued path expression or input parameter is a NULL value.
final class	NullExpression	A null Expression is used instead of a true null, which allows operations to be performed without doing a null check first.
final class	NullIfExpression	NULLIF returns the first expression if the two expressions are not equal.
final class	NumericLiteral	Exact numeric literals support the use of Java integer literal syntax as well as SQL exact numeric literal syntax.
final class	ObjectExpression	Stand-alone identification variables in the SELECT clause may optionally be qualified by the OBJECT operator.
final class	OnClause	Returns an expression that allows a join ON clause to be defined.
final class	OrderByClause	The ORDER BY clause allows the objects or values that are returned by the query to be ordered.
final class	OrderByItem	An orderby_item must be one of the following: A state_field_path_expression that evaluates to an orderable state field of an entity or embeddable class abstract schema type designated in the SELECT clause by one of the following: A general_identification_variable A single_valued_object_path_expression A state_field_path_expression that evaluates to the same state field of the same entity or embeddable abstract schema type as a state_field_path_expression in the SELECT clause A result_variable that refers to an orderable item in the SELECT clause for which the same result_variable has been specified.
final class	OrderSiblingsByClause	In a hierarchical query, if the rows of siblings of the same parent need to be ordered, then the ORDER SIBLINGS BY clause should be used.
final class	OrExpression	The OR logical operator chains multiple criteria together.
final class	RangeVariableDeclaration	Range variable declarations allow the developer to designate a "root" for objects which may not be reachable by navigation.
final class	RegexpExpression	The REGEXP condition is used to specify a search for a pattern.
final class	ResultVariable	A result variable may be used to name a select item in the query result.
final class	SelectClause	The SELECT clause queries data from entities.
final class	SelectStatement	A SELECT query is an operation that retrieves data from one or more tables or views.
final class	SimpleFromClause	The FROM clause of a query defines the domain of the query by declaring identification variables.
final class	SimpleSelectClause	The SELECT statement queries data from entities.
final class	SimpleSelectStatement	BNFL subquery ::= simple_select_clause subquery_from_clause [where_clause] [groupby_clause] [having_clause]
final class	SizeExpression	The SIZE function returns an integer value, the number of elements of the collection.
final class	SqrtExpression	The SQRT function takes a numeric argument and returns a double.
final class	StartWithClause	A START WITH clause is optional and specifies the root row(s) of the hierarchy.
final class	StateFieldPathExpression	A single_valued_association_field is designated by the name of an association-field in a one-to-one or many-to-one relationship.
final class	StringLiteral	A string literal is enclosed in single quotes.
final class	SubExpression	This expression wraps a sub-expression within parenthesis.
final class	SubstringExpression	The second and third arguments of the SUBSTRING function denote the starting position and length of the substring to be returned.
final class	SubtractionExpression	One of the four binary operators.
final class	SumFunction	One of the aggregate functions.
final class	TableExpression	Defines a table expression.
final class	TableVariableDeclaration	Defines a table expression.
final class	TreatExpression	Returns an expression that allows to treat its base as if it were a subclass of the class returned by the base.
final class	TrimExpression	The TRIM function trims the specified character from a string.
final class	TypeExpression	An entity type expression can be used to restrict query polymorphism.
final class	UnionClause	The UNION clause allows the results of two queries to be combined.
final class	UnknownExpression	This expression contains a portion of the query that is unknown to the parser.
final class	UpdateClause	This is the update clause of the update statement.
final class	UpdateItem	The new_value specified for an update operation must be compatible in type with the field to which it is assigned.
final class	UpdateStatement	The UPDATE clause of a query consists of a conditional expression used to select objects or values that satisfy the expression.
final class	UpperExpression	The UPPER function converts a string to upper case and it returns a string.
final class	ValueExpression	An identification variable qualified by the VALUE operator is a path expression.
final class	WhenClause	A WHEN predicate is used to calculate a condition and when it's true, its THEN will be executed.
final class	WhereClause	The WHERE clause of a query consists of a conditional expression used to select objects or values that satisfy the expression.

Methods in org.eclipse.persistence.jpa.jpql.parser that return Expression

Modifier and Type	Method	Description
protected final Expression	AbstractExpression.buildStringExpression(char value)	Creates a new Expression wrapping the given character value.
protected final Expression	AbstractExpression.buildStringExpression(String value)	Creates a new Expression wrapping the given string value.
final Expression	AbstractFromClause.getAsOfClause()	Returns the Expression representing the AS OF clause.
Expression	CaseExpression.getCaseOperand()	Returns the Expression that represents the CASE operand.
Expression	CollectionExpression.getChild(int index)	Retrieves the child Expression at the given position.
Expression	CollectionMemberDeclaration.getCollectionValuedPathExpression()	Returns the Expression representing the collection member, which is declared by an identification variable.
Expression	CollectionMemberExpression.getCollectionValuedPathExpression()	Returns the Expression representing the collection-valued path expression.
Expression	TreatExpression.getCollectionValuedPathExpression()	Returns the Expression that represents the collection-valued path expression.
final Expression	AbstractConditionalClause.getConditionalExpression()	Returns the expression representing the composition of the conditional expressions.
Expression	HierarchicalQueryClause.getConnectByClause()	Returns the Expression representing the CONNECT BY clause.
Expression	ConstructorExpression.getConstructorItems()	Returns the constructor items aggregated into a single expression and separated by commas or a single expression.
Expression	CastExpression.getDatabaseType()	Returns the database type to cast to.
Expression	LocalExpression.getDateType()	Returns the Expression representing the expression with date type.
final Expression	AbstractFromClause.getDeclaration()	Returns the Expression that represents the declaration of this clause.
Expression	CollectionMemberExpression.getEntityExpression()	Returns the Expression representing the entity expression.
Expression	TreatExpression.getEntityType()	Returns the Expression that represents the entity type that will be used to downcast the type of the elements in the collection.
Expression	LikeExpression.getEscapeCharacter()	Returns the Expression that represents the escape character, which is either a single character or an input parameter.
final Expression	AbstractSingleEncapsulatedExpression.getExpression()	Returns the Expression that is encapsulated within parenthesis.
Expression	ArithmeticFactor.getExpression()	Returns the Expression representing the arithmetic primary.
Expression	AsOfClause.getExpression()	Returns the Expression representing the timestamp or change number.
Expression	BadExpression.getExpression()	Returns the Expression that was parsed but grammatically, it is not a valid location.
Expression	BetweenExpression.getExpression()	Returns the Expression representing the expression to be tested for a range of values.
Expression	ConnectByClause.getExpression()	Returns the Expression representing the relationship expression.
Expression	EmptyCollectionComparisonExpression.getExpression()	Returns the Expression that represents the collection-valued path expression if it was parsed.
Expression	InExpression.getExpression()	Returns the Expression that represents the state field path expression or type discriminator.
Expression	JPQLExpression.getExpression(String actualQuery, int position)	Returns the deepest Expression for the given position.
Expression	NotExpression.getExpression()	Returns the Expression representing the expression that is negated.
Expression	NullComparisonExpression.getExpression()	Returns the expression being tested for being null.
Expression	OrderByItem.getExpression()	Returns the Expression that represents the order by expression.
Expression	QueryPosition.getExpression()	Returns the child Expression where the position of the cursor is.
final Expression	AbstractDoubleEncapsulatedExpression.getFirstExpression()	Returns the Expression that represents the first expression.
final Expression	AbstractTripleEncapsulatedExpression.getFirstExpression()	Returns the Expression that represents the first expression.
final Expression	AbstractSelectStatement.getFromClause()	Returns the Expression representing the FROM clause.
final Expression	AbstractSelectStatement.getGroupByClause()	Returns the Expression representing the GROUP BY clause.
Expression	GroupByClause.getGroupByItems()	Returns the Expression that represents the list of group by items if any was parsed.
final Expression	AbstractSelectStatement.getHavingClause()	Returns the Expression representing the HAVING clause.
final Expression	AbstractFromClause.getHierarchicalQueryClause()	Returns the Expression representing the hierarchical query clause.
final Expression	AbstractPathExpression.getIdentificationVariable()	Returns the identification variable that starts the path expression, which can be a sample identification variable, a map value, map key or map entry expression.
Expression	CollectionMemberDeclaration.getIdentificationVariable()	Returns the Expression representing the identification variable, which maps the collection-valued path expression.
Expression	Join.getIdentificationVariable()	Returns the Expression that represents the identification variable.
Expression	RangeVariableDeclaration.getIdentificationVariable()	Returns the Expression that represents the identification variable.
Expression	TableVariableDeclaration.getIdentificationVariable()	Returns the Expression that represents the identification variable.
Expression	InExpression.getInItems()	Returns the Expression that represents the list if items.
Expression	Join.getJoinAssociationPath()	Returns the Expression that represents the join association path expression.
Expression	IdentificationVariableDeclaration.getJoins()	Returns the unique join (fetch join) or the list of joins (fetch joins) expression.
final Expression	CompoundExpression.getLeftExpression()	Returns the Expression that represents the first expression, which is before the identifier.
Expression	BetweenExpression.getLowerBoundExpression()	Returns the Expression representing the lower bound expression.
Expression	UpdateItem.getNewValue()	Returns the Expression representing the new value, which is the new value of the property.
Expression	Join.getOnClause()	Returns the Expression that represents the ON clause if present.
Expression	SelectStatement.getOrderByClause()	Returns the Expression representing the ORDER BY clause.
final Expression	AbstractOrderByClause.getOrderByItems()	Returns the Expression representing the list of items to order.
Expression	HierarchicalQueryClause.getOrderSiblingsByClause()	Returns the Expression representing the ORDER SIBLINGS BY clause.
Expression	Expression.getParent()	Returns the parent of this Expression.
Expression	LikeExpression.getPatternValue()	Returns the Expression that represents the pattern value.
Expression	RegexpExpression.getPatternValue()	Returns the Expression that represents the pattern value.
Expression	UnionClause.getQuery()	Returns the Expression representing the unioned query.
Expression	JPQLExpression.getQueryStatement()	Returns the Expression representing the query, which is either a SELECT, a DELETE or an UPDATE clause.
Expression	DeleteClause.getRangeVariableDeclaration()	Returns the Expression representing the range variable declaration.
Expression	IdentificationVariableDeclaration.getRangeVariableDeclaration()	Returns the variable declaration, which is the abstract schema name and the identification variable.
Expression	UpdateClause.getRangeVariableDeclaration()	Returns the Expression representing the range variable declaration.
Expression	ResultVariable.getResultVariable()	Returns the Expression representing the result variable.
final Expression	CompoundExpression.getRightExpression()	Returns the Expression that represents the second expression, which is after the identifier.
Expression	RangeVariableDeclaration.getRootObject()	Returns the Expression that represents the "root" object.
final Expression	AbstractDoubleEncapsulatedExpression.getSecondExpression()	Returns the Expression that represents the second expression.
final Expression	AbstractTripleEncapsulatedExpression.getSecondExpression()	Returns the Expression that represents the second expression.
final Expression	AbstractSelectStatement.getSelectClause()	Returns the AbstractSelectClause representing the SELECT clause.
final Expression	AbstractSelectClause.getSelectExpression()	Returns the Expression representing the select items.
Expression	ResultVariable.getSelectExpression()	Returns the Expression representing the select expression.
Expression	HierarchicalQueryClause.getStartWithClause()	Returns the Expression representing the START WITH clause.
Expression	UpdateItem.getStateFieldPathExpression()	Returns the Expression representing the state field path expression, which is the property that should get updated.
Expression	LikeExpression.getStringExpression()	Returns the Expression that represents the string expression.
Expression	RegexpExpression.getStringExpression()	Returns the Expression that represents the string expression.
final Expression	AbstractTripleEncapsulatedExpression.getThirdExpression()	Returns the Expression that represents the first expression.
Expression	TrimExpression.getTrimCharacter()	Returns the character used for trimming the string.
Expression	SelectStatement.getUnionClauses()	Returns the Expression representing the UNION clauses.
Expression	JPQLExpression.getUnknownEndingStatement()	Returns the Expression that may contain a portion of the query that could not be parsed, this happens when the query is either incomplete or malformed.
Expression	UpdateClause.getUpdateItems()	Returns the Expression representing the single update item or the collection of update items.
Expression	BetweenExpression.getUpperBoundExpression()	Returns the Expression representing the upper bound expression.
final Expression	AbstractSelectStatement.getWhereClause()	Returns the Expression representing the WHERE clause.
Expression	DeleteStatement.getWhereClause()	Returns the Expression representing the WHERE clause.
Expression	UpdateStatement.getWhereClause()	Returns the Expression representing the WHERE clause.

Methods in org.eclipse.persistence.jpa.jpql.parser that return types with arguments of type Expression

Modifier and Type	Method	Description
final ListIterable<Expression>	AbstractExpression.children()
ListIterable<Expression>	Expression.children()	Returns the children of this Expression.
final ListIterable<Expression>	AbstractExpression.orderedChildren()
ListIterable<Expression>	Expression.orderedChildren()	Returns the list representing this Expression and its children.

Methods in org.eclipse.persistence.jpa.jpql.parser with parameters of type Expression

Modifier and Type	Method	Description
void	QueryPosition.addPosition(Expression expression, int position)	Adds the position of the cursor within the given Expression
protected final int	AbstractExpression.calculatePosition(Expression expression, int length)	Calculates the position of the given Expression by calculating the length of what is before.
JPQLQueryBNF	AbstractConditionalClause.findQueryBNF(Expression expression)
JPQLQueryBNF	AbstractDoubleEncapsulatedExpression.findQueryBNF(Expression expression)
JPQLQueryBNF	AbstractExpression.findQueryBNF(Expression expression)
final JPQLQueryBNF	AbstractFromClause.findQueryBNF(Expression expression)
final JPQLQueryBNF	AbstractOrderByClause.findQueryBNF(Expression expression)
final JPQLQueryBNF	AbstractPathExpression.findQueryBNF(Expression expression)
JPQLQueryBNF	AbstractSelectClause.findQueryBNF(Expression expression)
JPQLQueryBNF	AbstractSelectStatement.findQueryBNF(Expression expression)
JPQLQueryBNF	AbstractSingleEncapsulatedExpression.findQueryBNF(Expression expression)
JPQLQueryBNF	AbstractTripleEncapsulatedExpression.findQueryBNF(Expression expression)
JPQLQueryBNF	ArithmeticExpression.findQueryBNF(Expression expression)
JPQLQueryBNF	ArithmeticFactor.findQueryBNF(Expression expression)
JPQLQueryBNF	AsOfClause.findQueryBNF(Expression expression)
JPQLQueryBNF	BadExpression.findQueryBNF(Expression expression)
JPQLQueryBNF	BetweenExpression.findQueryBNF(Expression expression)
JPQLQueryBNF	CaseExpression.findQueryBNF(Expression expression)
JPQLQueryBNF	CollectionExpression.findQueryBNF(Expression expression)
JPQLQueryBNF	CollectionMemberDeclaration.findQueryBNF(Expression expression)
JPQLQueryBNF	CollectionMemberExpression.findQueryBNF(Expression expression)
JPQLQueryBNF	CompoundExpression.findQueryBNF(Expression expression)
JPQLQueryBNF	ConnectByClause.findQueryBNF(Expression expression)
JPQLQueryBNF	ConstructorExpression.findQueryBNF(Expression expression)
JPQLQueryBNF	DeleteClause.findQueryBNF(Expression expression)
JPQLQueryBNF	DeleteStatement.findQueryBNF(Expression expression)
JPQLQueryBNF	EmptyCollectionComparisonExpression.findQueryBNF(Expression expression)
JPQLQueryBNF	Expression.findQueryBNF(Expression expression)	Retrieves the JPQLQueryBNF that represents the fragment of this Expression that was used when parsing the given Expression.
JPQLQueryBNF	GroupByClause.findQueryBNF(Expression expression)
JPQLQueryBNF	HierarchicalQueryClause.findQueryBNF(Expression expression)
JPQLQueryBNF	IdentificationVariableDeclaration.findQueryBNF(Expression expression)
JPQLQueryBNF	InExpression.findQueryBNF(Expression expression)
JPQLQueryBNF	Join.findQueryBNF(Expression expression)
JPQLQueryBNF	LikeExpression.findQueryBNF(Expression expression)
JPQLQueryBNF	NotExpression.findQueryBNF(Expression expression)
JPQLQueryBNF	NullComparisonExpression.findQueryBNF(Expression expression)
JPQLQueryBNF	NullExpression.findQueryBNF(Expression expression)
JPQLQueryBNF	OrderByItem.findQueryBNF(Expression expression)
JPQLQueryBNF	RangeVariableDeclaration.findQueryBNF(Expression expression)
JPQLQueryBNF	RegexpExpression.findQueryBNF(Expression expression)
JPQLQueryBNF	ResultVariable.findQueryBNF(Expression expression)
JPQLQueryBNF	SelectStatement.findQueryBNF(Expression expression)
JPQLQueryBNF	SubExpression.findQueryBNF(Expression expression)
JPQLQueryBNF	TableVariableDeclaration.findQueryBNF(Expression expression)
final JPQLQueryBNF	TreatExpression.findQueryBNF(Expression expression)
JPQLQueryBNF	UnionClause.findQueryBNF(Expression expression)
JPQLQueryBNF	UnknownExpression.findQueryBNF(Expression expression)
JPQLQueryBNF	UpdateClause.findQueryBNF(Expression expression)
JPQLQueryBNF	UpdateItem.findQueryBNF(Expression expression)
JPQLQueryBNF	UpdateStatement.findQueryBNF(Expression expression)
JPQLQueryBNF	WhenClause.findQueryBNF(Expression expression)
int	QueryPosition.getPosition(Expression expression)	Returns the position of the cursor within the given Expression
int	CollectionExpression.indexOf(Expression expression)	Retrieves the index of the given Expression.
boolean	AbstractExpression.isAncestor(Expression expression)
boolean	Expression.isAncestor(Expression expression)	Determines whether this Expression is a parent of the given Expression.
protected boolean	AbstractConditionalClause.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	AbstractDoubleEncapsulatedExpression.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	AbstractEncapsulatedExpression.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	AbstractExpression.isParsingComplete(WordParser wordParser, String word, Expression expression)	Determines whether the parsing is complete based on what is left in the given text.
protected boolean	AbstractFromClause.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	AbstractTripleEncapsulatedExpression.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	AndExpression.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	ArithmeticExpression.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	ArithmeticFactor.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	BadExpression.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	BetweenExpression.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	CaseExpression.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	CastExpression.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	CollectionMemberDeclaration.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	ComparisonExpression.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	ConstructorExpression.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	DivisionExpression.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	ExtractExpression.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	IdentificationVariableDeclaration.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	InExpression.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	Join.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	LikeExpression.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	LogicalExpression.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	MultiplicationExpression.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	NotExpression.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	OnClause.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	OrderByItem.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	RangeVariableDeclaration.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	RegexpExpression.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	SelectStatement.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	TableVariableDeclaration.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	TreatExpression.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	UnionClause.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	UpdateClause.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	UpdateItem.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	WhenClause.isParsingComplete(WordParser wordParser, String word, Expression expression)
protected boolean	WhereClause.isParsingComplete(WordParser wordParser, String word, Expression expression)
void	QueryPosition.setExpression(Expression expression)	Sets the deepest leaf where the cursor is located.
protected final void	AbstractTraverseChildrenVisitor.visit(Expression expression)
protected void	AbstractTraverseParentVisitor.visit(Expression expression)
protected void	AnonymousExpressionVisitor.visit(Expression expression)	Blindly visit the given Expression.
protected void	ExpressionVisitorWrapper.visit(Expression expression)

Method parameters in org.eclipse.persistence.jpa.jpql.parser with type arguments of type Expression

Modifier and Type	Method	Description
protected final void	AbstractConditionalClause.addChildrenTo(Collection<Expression> children)
protected void	AbstractDoubleEncapsulatedExpression.addChildrenTo(Collection<Expression> children)
protected void	AbstractExpression.addChildrenTo(Collection<Expression> children)	Adds the children of this AbstractExpression to the given collection.
protected void	AbstractFromClause.addChildrenTo(Collection<Expression> children)
protected void	AbstractOrderByClause.addChildrenTo(Collection<Expression> children)
protected void	AbstractPathExpression.addChildrenTo(Collection<Expression> children)
protected void	AbstractSelectClause.addChildrenTo(Collection<Expression> children)
protected void	AbstractSelectStatement.addChildrenTo(Collection<Expression> children)
protected final void	AbstractSingleEncapsulatedExpression.addChildrenTo(Collection<Expression> children)
protected void	AbstractTripleEncapsulatedExpression.addChildrenTo(Collection<Expression> children)
protected void	ArithmeticFactor.addChildrenTo(Collection<Expression> children)
protected void	AsOfClause.addChildrenTo(Collection<Expression> children)
protected void	BadExpression.addChildrenTo(Collection<Expression> children)
protected void	BetweenExpression.addChildrenTo(Collection<Expression> children)
protected void	CaseExpression.addChildrenTo(Collection<Expression> children)
protected void	CollectionExpression.addChildrenTo(Collection<Expression> children)
protected void	CollectionMemberDeclaration.addChildrenTo(Collection<Expression> children)
protected void	CollectionMemberExpression.addChildrenTo(Collection<Expression> children)
protected final void	CompoundExpression.addChildrenTo(Collection<Expression> children)
protected void	ConnectByClause.addChildrenTo(Collection<Expression> children)
protected void	ConstructorExpression.addChildrenTo(Collection<Expression> children)
protected void	DeleteClause.addChildrenTo(Collection<Expression> children)
protected void	DeleteStatement.addChildrenTo(Collection<Expression> children)
protected void	EmptyCollectionComparisonExpression.addChildrenTo(Collection<Expression> children)
protected void	GroupByClause.addChildrenTo(Collection<Expression> children)
protected void	HierarchicalQueryClause.addChildrenTo(Collection<Expression> children)
protected void	IdentificationVariableDeclaration.addChildrenTo(Collection<Expression> children)
protected void	InExpression.addChildrenTo(Collection<Expression> children)
protected void	Join.addChildrenTo(Collection<Expression> children)
protected void	JPQLExpression.addChildrenTo(Collection<Expression> children)
protected void	LikeExpression.addChildrenTo(Collection<Expression> children)
protected void	LocalDateTime.addChildrenTo(Collection<Expression> children)
protected void	LocalExpression.addChildrenTo(Collection<Expression> children)
protected void	NotExpression.addChildrenTo(Collection<Expression> children)
protected void	NullComparisonExpression.addChildrenTo(Collection<Expression> children)
protected void	OrderByItem.addChildrenTo(Collection<Expression> children)
protected void	RangeVariableDeclaration.addChildrenTo(Collection<Expression> children)
protected void	RegexpExpression.addChildrenTo(Collection<Expression> children)
protected void	ResultVariable.addChildrenTo(Collection<Expression> children)
protected void	SelectStatement.addChildrenTo(Collection<Expression> children)
protected void	TableVariableDeclaration.addChildrenTo(Collection<Expression> children)
protected void	TreatExpression.addChildrenTo(Collection<Expression> children)
protected void	UnionClause.addChildrenTo(Collection<Expression> children)
protected void	UpdateClause.addChildrenTo(Collection<Expression> children)
protected void	UpdateItem.addChildrenTo(Collection<Expression> children)
protected void	UpdateStatement.addChildrenTo(Collection<Expression> children)
protected void	WhenClause.addChildrenTo(Collection<Expression> children)
protected final void	AbstractConditionalClause.addOrderedChildrenTo(List<Expression> children)
protected final void	AbstractEncapsulatedExpression.addOrderedChildrenTo(List<Expression> children)
protected void	AbstractExpression.addOrderedChildrenTo(List<Expression> children)	Adds the children of this AbstractExpression to the given list.
protected void	AbstractFromClause.addOrderedChildrenTo(List<Expression> children)
protected void	AbstractOrderByClause.addOrderedChildrenTo(List<Expression> children)
protected final void	AbstractPathExpression.addOrderedChildrenTo(List<Expression> children)
protected void	AbstractSchemaName.addOrderedChildrenTo(List<Expression> children)
protected void	AbstractSelectClause.addOrderedChildrenTo(List<Expression> children)
protected void	AbstractSelectStatement.addOrderedChildrenTo(List<Expression> children)
protected void	ArithmeticFactor.addOrderedChildrenTo(List<Expression> children)
protected void	AsOfClause.addOrderedChildrenTo(List<Expression> children)
protected void	BadExpression.addOrderedChildrenTo(List<Expression> children)
protected void	BetweenExpression.addOrderedChildrenTo(List<Expression> children)
protected void	CaseExpression.addOrderedChildrenTo(List<Expression> children)
protected void	CollectionExpression.addOrderedChildrenTo(List<Expression> children)
protected void	CollectionMemberDeclaration.addOrderedChildrenTo(List<Expression> children)
protected void	CollectionMemberExpression.addOrderedChildrenTo(List<Expression> children)
protected final void	CompoundExpression.addOrderedChildrenTo(List<Expression> children)
protected void	ConnectByClause.addOrderedChildrenTo(List<Expression> children)
protected void	ConstructorExpression.addOrderedChildrenTo(List<Expression> children)
protected void	DateTime.addOrderedChildrenTo(List<Expression> children)
protected void	DeleteClause.addOrderedChildrenTo(List<Expression> children)
protected void	DeleteStatement.addOrderedChildrenTo(List<Expression> children)
protected void	EmptyCollectionComparisonExpression.addOrderedChildrenTo(List<Expression> children)
protected void	EntityTypeLiteral.addOrderedChildrenTo(List<Expression> children)
protected void	GroupByClause.addOrderedChildrenTo(List<Expression> children)
protected void	HierarchicalQueryClause.addOrderedChildrenTo(List<Expression> children)
protected void	IdentificationVariable.addOrderedChildrenTo(List<Expression> children)
protected void	IdentificationVariableDeclaration.addOrderedChildrenTo(List<Expression> children)
protected void	InExpression.addOrderedChildrenTo(List<Expression> children)
protected void	InputParameter.addOrderedChildrenTo(List<Expression> children)
protected void	Join.addOrderedChildrenTo(List<Expression> children)
protected void	JPQLExpression.addOrderedChildrenTo(List<Expression> children)
protected void	KeywordExpression.addOrderedChildrenTo(List<Expression> children)
protected void	LikeExpression.addOrderedChildrenTo(List<Expression> children)
protected void	LocalDateTime.addOrderedChildrenTo(List<Expression> children)
protected void	LocalExpression.addOrderedChildrenTo(List<Expression> children)
protected void	NotExpression.addOrderedChildrenTo(List<Expression> children)
protected void	NullComparisonExpression.addOrderedChildrenTo(List<Expression> children)
protected void	NumericLiteral.addOrderedChildrenTo(List<Expression> children)
protected void	OrderByItem.addOrderedChildrenTo(List<Expression> children)
protected void	RangeVariableDeclaration.addOrderedChildrenTo(List<Expression> children)
protected void	RegexpExpression.addOrderedChildrenTo(List<Expression> children)
protected void	ResultVariable.addOrderedChildrenTo(List<Expression> children)
protected void	SelectStatement.addOrderedChildrenTo(List<Expression> children)
protected void	StringLiteral.addOrderedChildrenTo(List<Expression> children)
protected void	TableVariableDeclaration.addOrderedChildrenTo(List<Expression> children)
protected void	UnionClause.addOrderedChildrenTo(List<Expression> children)
protected void	UnknownExpression.addOrderedChildrenTo(List<Expression> children)
protected void	UpdateClause.addOrderedChildrenTo(List<Expression> children)
protected void	UpdateItem.addOrderedChildrenTo(List<Expression> children)
protected void	UpdateStatement.addOrderedChildrenTo(List<Expression> children)
protected void	WhenClause.addOrderedChildrenTo(List<Expression> children)
protected void	AbstractDoubleEncapsulatedExpression.addOrderedEncapsulatedExpressionTo(List<Expression> children)
protected abstract void	AbstractEncapsulatedExpression.addOrderedEncapsulatedExpressionTo(List<Expression> children)	Adds the Expressions representing the encapsulated Expression.
protected void	AbstractSingleEncapsulatedExpression.addOrderedEncapsulatedExpressionTo(List<Expression> children)
protected void	AbstractTripleEncapsulatedExpression.addOrderedEncapsulatedExpressionTo(List<Expression> children)
protected void	AggregateFunction.addOrderedEncapsulatedExpressionTo(List<Expression> children)
protected void	CastExpression.addOrderedEncapsulatedExpressionTo(List<Expression> children)
protected void	ExtractExpression.addOrderedEncapsulatedExpressionTo(List<Expression> children)
protected void	FunctionExpression.addOrderedEncapsulatedExpressionTo(List<Expression> children)
protected void	TreatExpression.addOrderedEncapsulatedExpressionTo(List<Expression> children)
protected void	TrimExpression.addOrderedEncapsulatedExpressionTo(List<Expression> children)

Uses of Expression in org.eclipse.persistence.jpa.jpql.tools

Classes in org.eclipse.persistence.jpa.jpql.tools with type parameters of type Expression

Modifier and Type	Class	Description
protected static class	AbstractContentAssistVisitor.AbstractConditionalClauseCollectionHelper<T extends Expression>	This helper handles adding proposals within a conditional expression that might be parsed as a single expression or has a collection of expression, which means the fragment is either incomplete or invalid.
protected static interface	AbstractContentAssistVisitor.CollectionExpressionHelper<T extends Expression>	This helper is used to determine how to add proposals within a collection of expressions.
protected static interface	AbstractContentAssistVisitor.StatementHelper<T extends Expression>	This helper helps to add JPQL identifiers for the clauses that make up a query statement and also chains the clauses within the query.

Fields in org.eclipse.persistence.jpa.jpql.tools declared as Expression

Modifier and Type	Field	Description
protected Expression	AbstractContentAssistVisitor.FollowingInvalidExpressionVisitor.expression	The Expression used to determine if it follows an invalid fragment or not.
protected Expression	AbstractContentAssistVisitor.InvalidExpressionVisitor.expression	The invalid Expression, which is either UnknownExpression or BadExpression.
protected Expression	EclipseLinkContentAssistVisitor.TableExpressionVisitor.expression	The Expression being visited.
protected Expression	JPQLQueryContext.QueryExpressionVisitor.expression	The Expression that is the beginning of a query.
protected Expression	AbstractContentAssistVisitor.EndingQueryPositionBuilder.invalidExpression	The Expression containing the invalid fragment.

Fields in org.eclipse.persistence.jpa.jpql.tools with type parameters of type Expression

Modifier and Type	Field	Description
protected Map<String,Filter<Expression>>	AbstractContentAssistVisitor.identifierFilters	This map contains the Filter that is used to determine when an identifier is a valid proposal, some of them depends on the expression's type.
protected static final Filter<Expression>	AbstractContentAssistVisitor.INVALID_IDENTIFIER_FILTER	This Filter is used to say the Expression is invalid without doing anything.
protected Stack<Expression>	AbstractContentAssistVisitor.lockedExpressions	Used to prevent and infinite recursion when one of the visit method is virtually asking a child expression to be visited.
protected static final Filter<Expression>	AbstractContentAssistVisitor.VALID_IDENTIFIER_FILTER	This Filter is used to say the Expression is valid without doing anything.

Methods in org.eclipse.persistence.jpa.jpql.tools with type parameters of type Expression

Modifier and Type	Method	Description
protected <T extends Expression> void	AbstractContentAssistVisitor.visitCollectionExpression(T expression, String identifier, AbstractContentAssistVisitor.CollectionExpressionHelper<T> helper)	Adds the possible proposals for the given expression based on the location of the cursor and the content of the expression.
protected <T extends Expression> void	AbstractContentAssistVisitor.visitStatement(T expression, AbstractContentAssistVisitor.StatementHelper<T> helper)	Visits the given AbstractSelectStatement and checks to see if the identifiers of the following clauses can be added a valid proposals.

Methods in org.eclipse.persistence.jpa.jpql.tools that return Expression

Modifier and Type	Method	Description
Expression	JPQLQueryContext.getActualCurrentQuery()	Returns the current Expression being manipulated, which is either the top-level query or a subquery.
Expression	AbstractContentAssistVisitor.AbstractFromClauseStatementHelper.getClause(T expression)
Expression	AbstractContentAssistVisitor.AbstractGroupByClauseStatementHelper.getClause(T expression)
Expression	AbstractContentAssistVisitor.AbstractHavingClauseStatementHelper.getClause(T expression)
Expression	AbstractContentAssistVisitor.AbstractSelectClauseStatementHelper.getClause(AbstractSelectStatement expression)
Expression	AbstractContentAssistVisitor.AbstractWhereClauseSelectStatementHelper.getClause(T expression)
Expression	AbstractContentAssistVisitor.DeleteClauseStatementHelper.getClause(DeleteStatement expression)
Expression	AbstractContentAssistVisitor.OrderByClauseStatementHelper.getClause(SelectStatement expression)
Expression	AbstractContentAssistVisitor.StatementHelper.getClause(T expression)	Returns the clause being scanned by this helper.
Expression	AbstractContentAssistVisitor.UpdateClauseStatementHelper.getClause(UpdateStatement expression)
Expression	AbstractContentAssistVisitor.WhereClauseDeleteStatementHelper.getClause(DeleteStatement expression)
Expression	AbstractContentAssistVisitor.WhereClauseUpdateStatementHelper.getClause(UpdateStatement expression)
Expression	EclipseLinkContentAssistVisitor.UnionClauseStatementHelper.getClause(SelectStatement expression)
Expression	JPQLQueryContext.getCurrentQuery()	Returns the current Expression being manipulated, which is either the top-level query or a subquery.
Expression	JPQLQueryContext.getQueryExpression(Expression expression)	Retrieves the Expression representing the query statement (either the top-level query JPQLExpression or the subquery SimpleSelectStatement) owning the given Expression.

Methods in org.eclipse.persistence.jpa.jpql.tools that return types with arguments of type Expression

Modifier and Type	Method	Description
protected Filter<Expression>	AbstractContentAssistVisitor.buildCollectionCompoundTypeFilter()
protected Filter<Expression>	AbstractContentAssistVisitor.buildDifferentComparisonFilter()
protected Filter<Expression>	AbstractContentAssistVisitor.buildNonCollectionCompoundTypeFilter()
protected Filter<Expression>	AbstractContentAssistVisitor.getFilter(String identifier)

Methods in org.eclipse.persistence.jpa.jpql.tools with parameters of type Expression

Modifier and Type	Method	Description
boolean	AbstractContentAssistVisitor.DifferentComparisonFilter.accept(Expression expression)
protected abstract boolean	AbstractContentAssistVisitor.IdentificationVariableType.add(AbstractContentAssistVisitor contentAssist, Declaration declaration, Expression expression)	Adds the identification variables defined in the given Declaration.
void	AbstractContentAssistVisitor.AbstractConditionalClauseCollectionHelper.addAtTheEndOfChild(Expression expression, CollectionExpression collectionExpression, int index, boolean hasComma, boolean virtualSpace)
protected void	AbstractContentAssistVisitor.addComparisonIdentifiers(Expression expression)	Adds the JPQL identifiers which correspond to the comparison operators as valid proposals.
protected void	AbstractContentAssistVisitor.addCompoundIdentifier(String identifier, Expression expression, boolean hasIs, boolean hasNot)	Adds the given JPQL identifier as a valid proposal if its role is IdentifierRole.COMPOUND_FUNCTION and the beginning starts with the current word.
protected void	AbstractContentAssistVisitor.addCompoundIdentifiers(String queryBNFId, Expression expression, boolean hasIs, boolean hasNot)	Adds the JPQL identifiers that are registered with the given JPQLQueryBNF as valid proposals if their role is IdentifierRole.COMPOUND_FUNCTION and the beginning starts with the current word.
protected void	AbstractContentAssistVisitor.addCompoundIdentifiers(JPQLQueryBNF queryBNF, Expression expression, boolean hasIs, boolean hasNot)	Adds the JPQL identifiers that are registered with the given JPQLQueryBNF as valid proposals if their role is IdentifierRole.COMPOUND_FUNCTION and the beginning starts with the current word.
protected void	AbstractContentAssistVisitor.addFunctionIdentifiers(Expression expression)	Adds the JPQL identifiers for which their role is FUNCTION by determining the JPQLQueryBNF that represents the fragment for which the given Expression was parsed.
protected void	AbstractContentAssistVisitor.addIdentificationVariables(Expression expression, AbstractContentAssistVisitor.IdentificationVariableType type)	Adds the possible identification variables as valid proposals but filter them based on the given type.
void	AbstractContentAssistVisitor.AbstractConditionalClauseCollectionHelper.addIdentifier(Expression expression, String identifier)
protected void	AbstractContentAssistVisitor.addLeftIdentificationVariables(Expression expression)	Adds the identification variables defined in the current query's FROM clause that are declared before the given Expression.
protected void	BasicRefactoringTool.AbstractRenamer.addTextEdit(Expression expression, int extraOffset, String oldValue, String newValue)	Adds a new TextEdit with the given information.
protected void	BasicRefactoringTool.AbstractRenamer.addTextEdit(Expression expression, String oldValue, String newValue)	Adds a new TextEdit with the given information.
void	AbstractContentAssistVisitor.AbstractConditionalClauseCollectionHelper.addTheBeginningOfChild(Expression expression, CollectionExpression collectionExpression, int index, boolean hasComma)
protected boolean	AbstractContentAssistVisitor.areArithmeticSymbolsAppendable(Expression expression)	Determines whether the given Expression can be followed by an arithmetic operator.
protected boolean	AbstractContentAssistVisitor.areComparisonSymbolsAppendable(Expression expression)	Determines whether the given Expression can be followed by a comparison operator.
protected boolean	AbstractContentAssistVisitor.areLogicalSymbolsAppendable(Expression expression)	Determines whether the given Expression can be followed by a logical operator.
protected QueryPosition	AbstractContentAssistVisitor.buildEndingPositionFromInvalidExpression(Expression invalidExpression, Expression startingPointExpression, boolean[] virtualSpace)	Creates a new QueryPosition containing the corrected positions starting at the given Expression and traversing the children at is always at the right side of the tree.
protected JPQLQueryContext	DefaultJPQLQueryContext.buildJPQLQueryContext(JPQLQueryContext currentContext, Expression currentQuery)
protected JPQLQueryContext	EclipseLinkJPQLQueryContext.buildJPQLQueryContext(JPQLQueryContext currentContext, Expression currentQuery)
protected abstract JPQLQueryContext	JPQLQueryContext.buildJPQLQueryContext(JPQLQueryContext currentContext, Expression currentQuery)
protected Filter<IMapping>	AbstractContentAssistVisitor.buildMappingFilter(Expression expression)
boolean	AbstractContentAssistVisitor.AbstractConditionalClauseCollectionHelper.canContinue(Expression expression, CollectionExpression collectionExpression, int index)
protected IType	AbstractContentAssistVisitor.getAcceptableType(Expression expression)	Determines the root IType that any type should be assignable.
protected CollectionExpression	AbstractContentAssistVisitor.getCollectionExpression(Expression expression)	Casts the given Expression to a CollectionExpression if it is actually an object of that type.
DeclarationResolver	JPQLQueryContext.getDeclarationResolver(Expression expression)	Returns the DeclarationResolver of the current query's declaration.
protected IdentificationVariable	GenericSemanticValidatorHelper.getIdentificationVariable(Expression expression)
IManagedType	GenericSemanticValidatorHelper.getManagedType(Expression expression)
IMapping	JPQLQueryContext.getMapping(Expression expression)	Returns the IMapping for the field represented by the given Expression.
Expression	JPQLQueryContext.getQueryExpression(Expression expression)	Retrieves the Expression representing the query statement (either the top-level query JPQLExpression or the subquery SimpleSelectStatement) owning the given Expression.
Resolver	JPQLQueryContext.getResolver(Expression expression)	Creates or retrieved the cached Resolver for the given Expression.
protected Object	DefaultSemanticValidator.getType(Expression expression)
IType	GenericSemanticValidatorHelper.getType(Expression expression)
IType	JPQLQueryContext.getType(Expression expression)	Returns the IType of the given Expression.
ITypeDeclaration	GenericSemanticValidatorHelper.getTypeDeclaration(Expression expression)
ITypeDeclaration	JPQLQueryContext.getTypeDeclaration(Expression expression)	Returns the ITypeDeclaration of the field handled by this Resolver.
protected boolean	AbstractContentAssistVisitor.hasClausesDefinedBetween(Expression expression, String afterIdentifier, String beforeIdentifier)
protected boolean	AbstractContentAssistVisitor.isAppendable(Expression expression, AbstractContentAssistVisitor.AppendableType appendableType)	Determines whether a certain type of JPQL identifiers can be appended to the JPQL query based on the given Expression.
protected boolean	AbstractContentAssistVisitor.isAppendableToCollection(Expression expression)	Determines whether
protected boolean	DefaultSemanticValidator.isBooleanType(Expression expression)	Determines whether the given Expression is of the correct type based on these rules: The Expression returns a boolean value;
protected boolean	AbstractContentAssistVisitor.isClauseAppendable(Expression expression)	Determines whether the identifiers identifying clauses can be appended to the JPQL query based on the given Expression.
protected boolean	DefaultSemanticValidator.isComparisonEquivalentType(Expression expression1, Expression expression2)
protected boolean	AbstractContentAssistVisitor.isComplete(Expression expression)	Determines whether the given Expression is grammatically complete.
protected boolean	AbstractContentAssistVisitor.isCompoundable(Expression expression)	Determines whether the given Expression can be used as the left side of a compound expression.
protected boolean	AbstractContentAssistVisitor.isEncapsulated(Expression expression)	Determines whether the given Expression is being encapsulated or not.
protected boolean	DefaultSemanticValidator.isEquivalentBetweenType(Expression expression1, Expression expression2)
protected boolean	AbstractContentAssistVisitor.isFollowingInvalidExpression(Expression expression)	Determines whether the given Expression is preceded by an invalid expression.
protected boolean	AbstractContentAssistVisitor.isInSubquery(Expression expression)	Determines whether the given Expression is in a subquery or in the top-level query.
protected boolean	DefaultSemanticValidator.isIntegralType(Expression expression)	Determines whether the given Expression is of the correct type based on these rules: The Expression's type is an integral type (long or integer).
protected boolean	AbstractContentAssistVisitor.isInvalidExpression(Expression expression)	Determines whether the given Expression represents an invalid fragment.
protected boolean	AbstractContentAssistVisitor.isLocked(Expression expression)	Determines whether the given Expression has been set has the lock to prevent an infinite recursion.
protected boolean	AbstractContentAssistVisitor.isNotExpression(Expression expression)	Determines whether the given Expression represents the negated expression.
protected boolean	DefaultSemanticValidator.isNullValue(Expression expression)
protected boolean	DefaultSemanticValidator.isNumericType(Expression expression)	Determines whether the given Expression is of the correct type based on these rules: The Expression returns a numeric value;
protected boolean	DefaultSemanticValidator.isStringType(Expression expression)	Determines whether the given Expression is of the correct type based on these rules: The Expression's type is a string type.
protected boolean	AbstractContentAssistVisitor.isSubqueryAppendable(Expression expression)	Determines whether the JPQL identifier starting a subquery (SELECT) can be appended based on the given Expression which is preceding the position of the cursor.
protected boolean	EclipseLinkContentAssistVisitor.isTableExpression(Expression expression)
protected boolean	AbstractContentAssistVisitor.isValid(Expression expression, String queryBNFId)	Determines whether the given Expression part is an expression of the given query BNF.
protected boolean	AbstractContentAssistVisitor.isValid(Expression expression, JPQLQueryBNF queryBNF)	Determines whether the given Expression part is an expression of the given query BNF.
protected boolean	DefaultSemanticValidator.isValid(Expression expression, Class<? extends DefaultSemanticValidator.TypeValidator> validatorClass)	Determines whether the given Expression is of the correct type by using the DefaultSemanticValidator.TypeValidator.
protected boolean	AbstractContentAssistVisitor.isWithinInvalidExpression(Expression expression)	Determines whether the given Expression is part of an invalid fragment
String	JPQLQueryContext.literal(Expression expression, LiteralType type)	Retrieves the "literal" from the given Expression.
int	AbstractContentAssistVisitor.AbstractConditionalClauseCollectionHelper.maxCollectionSize(Expression expression)
void	JPQLQueryContext.newSubqueryContext(Expression currentQuery)	Changes the state of this context to use the given subquery.
int	AbstractContentAssistVisitor.AbstractConditionalClauseCollectionHelper.preExpressionLength(Expression expression)
void	AbstractContentAssistVisitor.EndingQueryPositionBuilder.prepare(Expression invalidExpression)	Prepares this visitor before visiting an Expression.
JPQLQueryBNF	AbstractContentAssistVisitor.AbstractConditionalClauseCollectionHelper.queryBNF(Expression expression, int index)
IMapping	GenericSemanticValidatorHelper.resolveMapping(Expression expression)
protected void	JPQLQueryContext.store(JPQLQueryContext parent, Expression currentQuery)	Stores the information contained in the given parent into this one.
void	AbstractJPQLQueryHelper.validate(Expression expression, List<JPQLQueryProblem> problems)	Validates the query by introspecting it grammatically and semantically.
protected boolean	DefaultSemanticValidator.validateBooleanType(Expression expression, String messageKey)	Determines whether the given Expression is of the correct type based on these rules: The Expression returns a boolean value; The Expression's type is a boolean type.
void	AbstractJPQLQueryHelper.validateGrammar(Expression expression, List<JPQLQueryProblem> problems)	Validates the query by only introspecting it grammatically.
protected boolean	DefaultSemanticValidator.validateIntegralType(Expression expression, String queryBNF, String messageKey)	Determines whether the given Expression is of the correct type based on these rules: The Expression returns a integral value; The Expression's type is an integral type (long or integer).
protected boolean	DefaultSemanticValidator.validateNumericType(Expression expression, String messageKey)	Determines whether the given Expression is of the correct type based on these rules: The Expression returns a numeric value; The Expression's type is an numeric type.
void	AbstractJPQLQueryHelper.validateSemantic(Expression expression, List<JPQLQueryProblem> problems)	Validates the query by only introspecting it semantically.
protected boolean	DefaultSemanticValidator.validateStringType(Expression expression, String messageKey)	Determines whether the given Expression is of the correct type based on these rules: The Expression returns a String value; The Expression's type is a String type.
protected void	AbstractContentAssistVisitor.AppendableExpressionVisitor.visit(Expression expression)
protected void	AbstractContentAssistVisitor.DifferentComparisonFilter.visit(Expression expression)
protected void	AbstractContentAssistVisitor.EncapsulatedExpressionVisitor.visit(Expression expression)
protected void	AbstractContentAssistVisitor.FollowingInvalidExpressionVisitor.visit(Expression expression)
protected void	AbstractContentAssistVisitor.visit(Expression expression)
protected void	AbstractContentAssistVisitor.VisitParentVisitor.visit(Expression expression)
protected void	BasicRefactoringTool.ClassNameRenamer.visit(Expression expression, String value, int extraOffset)	Visits the given and if its value is the same as the old class name or if the value represents an inner class of that old class name, then the given StateObjectUpdater will be notified to replace the value.
protected void	AbstractContentAssistVisitor.visitEndingExpression(Expression expression)
protected void	AbstractContentAssistVisitor.visitInvalidExpression(Expression expression)

Constructors in org.eclipse.persistence.jpa.jpql.tools with parameters of type Expression

Modifier	Constructor	Description
protected	DefaultJPQLQueryContext(JPQLQueryContext parent, Expression currentQuery)	Creates a new sub-DefaultJPQLQueryContext.
protected	EclipseLinkJPQLQueryContext(JPQLQueryContext parent, Expression currentQuery)	Creates a new EclipseLinkJPQLQueryContext.
protected	JPQLQueryContext(JPQLQueryContext parent, Expression currentQuery)	Creates a new sub-JPQLQueryContext.

Uses of Expression in org.eclipse.persistence.jpa.jpql.tools.model

Methods in org.eclipse.persistence.jpa.jpql.tools.model with type parameters of type Expression

Modifier and Type	Method	Description
protected <T extends Expression> List<T>	BasicStateObjectBuilder.children(Expression expression)

Methods in org.eclipse.persistence.jpa.jpql.tools.model with parameters of type Expression

Modifier and Type	Method	Description
protected <T extends StateObject> List<T>	BasicStateObjectBuilder.buildChildren(Expression expression)
AbstractIdentificationVariableDeclarationStateObject	BasicStateObjectBuilder.AbstractRangeDeclarationBuilder.buildStateObject(S parent, Expression expression)
T	BasicStateObjectBuilder.AbstractSelectStatementBuilder.buildStateObject(P parent, Expression expression)
CollectionMemberDeclarationStateObject	BasicStateObjectBuilder.CollectionMemberDeclarationBuilder.buildStateObject(AbstractFromClauseStateObject parent, Expression expression)
DeleteStatementStateObject	BasicStateObjectBuilder.DeleteStatementBuilder.buildStateObject(JPQLQueryStateObject parent, Expression expression)
JoinStateObject	BasicStateObjectBuilder.JoinBuilder.buildStateObject(AbstractIdentificationVariableDeclarationStateObject parent, Expression expression)
StateObject	BasicStateObjectBuilder.SelectItemBuilder.buildStateObject(SelectClauseStateObject parent, Expression expression)
UpdateStatementStateObject	BasicStateObjectBuilder.UpdateStatementBuilder.buildStateObject(JPQLQueryStateObject parent, Expression expression)
CaseExpressionStateObject	BasicStateObjectBuilder.WhenClauseBuilder.buildStateObject(CaseExpressionStateObject parent, Expression expression)
T	IBuilder.buildStateObject(S parent, Expression expression)	Creates the StateObject representation of the given Expression.
protected final StateObject	BasicStateObjectBuilder.buildStateObjectImp(Expression expression)	Visits the given Expression and returned its StateObject.
protected <T extends Expression> List<T>	BasicStateObjectBuilder.children(Expression expression)
protected String	BasicStateObjectBuilder.literal(Expression expression, LiteralType type)	Retrieves the "literal" from the given Expression.
protected boolean	AbstractActualJPQLQueryFormatter.shouldOutput(Expression expression)
protected void	BasicStateObjectBuilder.CollectionExpressionVisitor.visit(Expression expression)
protected void	BasicStateObjectBuilder.SelectItemBuilder.visit(Expression expression)

Uses of Expression in org.eclipse.persistence.jpa.jpql.tools.model.query

Methods in org.eclipse.persistence.jpa.jpql.tools.model.query that return Expression

Modifier and Type	Method	Description
Expression	AbstractStateObject.getExpression()
Expression	StateObject.getExpression()	Returns the actual parsed object if this StateObject representation of the JPQL query was created by parsing an existing JPQL query.

Methods in org.eclipse.persistence.jpa.jpql.tools.model.query with parameters of type Expression

Modifier and Type	Method	Description
void	AbstractStateObject.setExpression(Expression expression)	Sets the actual parsed object if this StateObject representation of the JPQL query is created by converting the parsed representation of the JPQL query.

Uses of Expression in org.eclipse.persistence.jpa.jpql.tools.resolver

Fields in org.eclipse.persistence.jpa.jpql.tools.resolver declared as Expression

Modifier and Type	Field	Description
protected Expression	Declaration.baseExpression	Either the range variable declaration if this is a range declaration otherwise the collection-valued path expression when this is a collection member declaration.
protected Expression	Declaration.declarationExpression	The declaration expression, which is either an IdentificationVariableDeclaration or a CollectionMemberDeclaration when part of a FROM clause, otherwise it's either the DeleteClause or the UpdateClause.

Methods in org.eclipse.persistence.jpa.jpql.tools.resolver that return Expression

Modifier and Type	Method	Description
Expression	Declaration.getBaseExpression()
Expression	Declaration.getDeclarationExpression()

Methods in org.eclipse.persistence.jpa.jpql.tools.resolver with parameters of type Expression

Modifier and Type	Method	Description
protected CollectionExpression	ResolverBuilder.getCollectionExpression(Expression expression)	Casts the given Expression to a CollectionExpression if it is actually an object of that type.
protected DeclarationResolver	ResolverBuilder.getDeclarationResolver(Expression expression)	Returns the DeclarationResolver of the current query's declaration.
void	DeclarationResolver.populate(Expression expression)	Visits the current query (which is either the top-level query or a subquery) and gathers the information from the declaration clause.
protected Resolver	DeclarationResolver.resolveRootObject(Expression expression)	Resolves the "root" object represented by the given Expression.
protected void	DeclarationResolver.RootObjectExpressionVisitor.visit(Expression expression)
protected void	ResolverBuilder.visitCollectionEquivalentExpression(Expression expression, Expression extraExpression)	Visits the given Expression and creates a Resolver that will check the type for each of its children.
protected String	DeclarationResolver.visitDeclaration(Expression expression, Expression identificationVariable)