StateObject classes that represents a JPQL query.See: Description
| Interface | Description |
|---|---|
| DeclarationStateObject |
This defines the declaration portion of a query, which is the
FROM clause
of a query. |
| EclipseLinkStateObjectVisitor |
The interface is used to traverse the
StateObject hierarchy that represents a JPQL
query as well as what EclipseLink adds on top of the basic grammar. |
| ListHolderStateObject<T> |
A
ListHolderStateObject is a StateObject having a list of children and this
gives access to some operation over the list. |
| StateObject |
A
StateObject is an editable representation of a JPQL query. |
| StateObjectProblem | |
| StateObjectVisitor |
The visitor is used to traverse the
StateObject hierarchy that represents a JPQL query. |
| VariableDeclarationStateObject |
This defines a variable declaration, which has a "root" object and an identification variable.
|
| Class | Description |
|---|---|
| AbsExpressionStateObject |
The
ABS function removes the minus sign from a specified argument and returns
the absolute value, which is always a positive number or zero. |
| AbstractConditionalClauseStateObject |
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.
|
| AbstractDoubleEncapsulatedExpressionStateObject |
This
StateObject represents a JPQL expression that has a JPQL identifier followed by
two an encapsulated expression with parenthesis, the two expression are separated by a comma. |
| AbstractEclipseLinkStateObjectVisitor |
The abstract definition of
EclipseLinkStateObjectVisitor, which implements all the
methods but does nothing. |
| AbstractEclipseLinkTraverseChildrenVisitor |
This
StateObjectVisitor traverses the entire hierarchy of the JPQL parsed tree by going
down into each of the children of any given StateObject. |
| AbstractEclipseLinkTraverseParentVisitor |
This
StateObjectVisitor traverses up the hierarchy. |
| AbstractEncapsulatedExpressionStateObject |
This expression handles parsing the identifier followed by an expression encapsulated within
parenthesis.
|
| AbstractFromClauseStateObject |
This state object represents the abstract definition of a
FROM clause, which
is either the FROM clause of the query or of a sub-query expression. |
| AbstractIdentificationVariableDeclarationStateObject | |
| AbstractListHolderStateObject<T extends StateObject> |
The abstraction definition of a
StateObject that holds onto a list of children, the
methods defined in ListHolderStateObject are automatically handled here. |
| AbstractModifyClauseStateObject | |
| AbstractModifyStatementStateObject |
The abstract definition of a modify statement.
|
| AbstractPathExpressionStateObject |
An identification variable followed by the navigation operator (.) and a state field or
association field is a path expression.
|
| AbstractRangeVariableDeclarationStateObject | |
| AbstractSchemaNameStateObject |
An abstract schema name designates the abstract schema type over which the query ranges.
|
| AbstractSelectClauseStateObject |
This state object represents the abstract definition of a
SELECT clause,
which is either the SELECT clause of the top-level query or of a subquery. |
| AbstractSelectStatementStateObject |
This state object represents the select statement, which has at least a
SELECT
clause and a FROM clause. |
| AbstractSingleEncapsulatedExpressionStateObject |
This
StateObject represents a JPQL expression that has a JPQL identifier followed by
an encapsulated expression with parenthesis. |
| AbstractStateObject |
The abstract definition of a
StateObject. |
| AbstractStateObjectVisitor |
The abstract definition of
StateObjectVisitor, which implements all the methods but does
nothing. |
| AbstractTraverseChildrenVisitor |
This
StateObjectVisitor traverses the entire hierarchy of the JPQL parsed tree by going
down into each of the children of any given StateObject. |
| AbstractTraverseParentVisitor |
This
StateObjectVisitor traverses up the hierarchy. |
| AbstractTripleEncapsulatedExpressionStateObject |
This state object takes care of parsing an expression that encapsulates three expressions
separated by a comma.
|
| AdditionExpressionStateObject |
TODO:
BNF:
arithmetic_expression ::= arithmetic_expression + arithmetic_term |
| AggregateFunctionStateObject |
In the
SELECT clause the result of a query may be the result of an aggregate
function applied to a path expression. |
| AllOrAnyExpressionStateObject |
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. |
| AndExpressionStateObject |
The
AND logical operator chains multiple criteria together. |
| AnonymousStateObjectVisitor |
This visitor allows a subclass to simply override
AnonymousStateObjectVisitor.visit(StateObject) and perform the
same task for all visited ItateObjects. |
| AnonynousEclipseLinkStateObjectVisitor |
This visitor allows a subclass to simply override
AnonymousStateObjectVisitor.visit(StateObject) and perform the
same task for all visited ItateObjects. |
| ArithmeticExpressionStateObject |
This expression represents an arithmetic expression, which means the first and second expressions
are aggregated with an arithmetic sign.
|
| ArithmeticFactorStateObject |
This state object simply adds a plus or minus sign to the arithmetic primary expression.
|
| AvgFunctionStateObject |
One of the aggregate functions.
|
| BadExpressionStateObject |
This wraps an invalid portion of the JPQL query that could not be parsed.
|
| BetweenExpressionStateObject |
Used in conditional expression to determine whether the result of an expression falls within an
inclusive range of values.
|
| CaseExpressionStateObject |
A
CASE predicate is used to calculate a condition and when it's true,
its THEN expression will be executed. |
| ChangeSupport |
This
ChangeSupport is responsible to notifies registered listeners upon changes made
to a StateObject, those changes are either a property has changed (IPropertyChangeListener)
or the content of a list has changed (IListChangeListener). |
| CoalesceExpressionStateObject |
A
COALESCE expression returns null if all its arguments evaluate
to null, and the value of the first non-null argument otherwise. |
| CollectionExpressionStateObject |
This
StateObject is a temporary object used to store a list of StateObjects. |
| CollectionMemberDeclarationStateObject |
An identification variable declared by a
collection_member_declaration ranges over
values of a collection obtained by navigation using a path expression. |
| CollectionMemberExpressionStateObject |
This expression tests whether the designated value is a member of the collection specified by the
collection-valued path expression.
|
| CollectionValuedPathExpressionStateObject |
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.
|
| ComparisonExpressionStateObject |
Only the values of like types are permitted to be compared.
|
| CompoundExpressionStateObject |
A compound
StateObject has a left and right expressions combined by an identifier. |
| ConcatExpressionStateObject |
The
CONCAT function returns a string that is a concatenation of its arguments. |
| ConstructorExpressionStateObject |
In the
SELECT clause a constructor may be used in the SELECT
list to return one or more Java instances. |
| CountFunctionStateObject |
One of the aggregate functions.
|
| DateTimeStateObject |
This
DateTimeStateObject represents a date or time. |
| DeleteClauseStateObject |
This is the
DELETE clause of the DELETE statement. |
| DeleteStatementStateObject |
Bulk delete operation apply to entities of a single entity class (together with its subclasses,
if any).
|
| DerivedPathIdentificationVariableDeclarationStateObject | |
| DerivedPathVariableDeclarationStateObject |
BNF: subselect_identification_variable_declaration ::= derived_path_expression [AS] identification_variable {join}*
BNF:
derived_path_expression ::= superquery_identification_variable. |
| DivisionExpressionStateObject |
TODO:
BNF:
arithmetic_expression ::= arithmetic_expression / arithmetic_term |
| EmptyCollectionComparisonExpressionStateObject |
This expression tests whether or not the collection designated by the collection-valued path
expression is empty (i.e, has no elements).
|
| EncapsulatedIdentificationVariableExpressionStateObject |
This object represents an identification variable that is wrapped by a function.
|
| EntityTypeLiteralStateObject |
This
StateObject wraps the name of an entity type. |
| EntryExpressionStateObject |
This object represents an identification variable that maps the
Map.Entry)
of a Map. |
| EnumTypeStateObject |
This
StateObject wraps the name of an Enum constant. |
| ExistsExpressionStateObject |
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. |
| FromClauseStateObject |
The
FROM clause of a query defines the domain of the query by declaring
identification variables. |
| FunctionExpressionStateObject | |
| GroupByClauseStateObject |
The
GROUP BY construct enables the aggregation of values according to the
properties of an entity class. |
| HavingClauseStateObject |
The
HAVING construct enables conditions to be specified that further restrict
the query result as restrictions upon the groups. |
| IdentificationVariableDeclarationStateObject |
An identification variable is a valid identifier declared in the
FROM clause
of a query. |
| IdentificationVariableStateObject |
This state object represents a single identification variable, which is identifying TODO.
|
| IndexExpressionStateObject |
The
INDEX function returns an integer value corresponding to the position of
its argument in an ordered list. |
| InExpressionStateObject |
The state field path expression must have a string, numeric, or enum value.
|
| InputParameterStateObject |
Either positional or named parameters may be used.
|
| JoinStateObject |
A
JOIN enables the fetching of an association as a side effect of the
execution of a query. |
| JPQLQueryStateObject |
This is the root of the
StateObject hierarchy that represents a JPQL query. |
| KeyExpressionStateObject |
This object represents an identification variable that maps the keys of a
Map. |
| KeywordExpressionStateObject |
The expression representing some keywords:
TRUE, FALSE or NULL. |
| LengthExpressionStateObject |
The
LENGTH function returns the length of the string in characters as an integer. |
| LikeExpressionStateObject |
The
LIKE condition is used to specify a search for a pattern. |
| LocateExpressionStateObject |
The
LOCATE function returns the position of a given string within a string,
starting the search at a specified position. |
| LogicalExpressionStateObject |
This expression represents a logical expression, which means the first and second expressions are
aggregated with either the
AND or the OR operator. |
| LowerExpressionStateObject |
The
LOWER function converts a string to lower case and it returns a string. |
| MaxFunctionStateObject |
One of the aggregate functions.
|
| MinFunctionStateObject |
One of the aggregate functions.
|
| ModExpressionStateObject |
The modulo operation finds the remainder of division of one number by another.
|
| MultiplicationExpressionStateObject |
TODO:
BNF:
arithmetic_expression ::= arithmetic_expression * arithmetic_term |
| NotExpressionStateObject |
BNF:
expression ::= NOT conditional_primary |
| NullComparisonExpressionStateObject |
A null comparison tests whether or not the single-valued path expression or input parameter is a
NULL value. |
| NullIfExpressionStateObject |
NULLIF returns the first expression if the two expressions are not equal. |
| NumericLiteralStateObject |
Exact numeric literals support the use of Java integer literal syntax as well as SQL exact
numeric literal syntax.
|
| ObjectExpressionStateObject |
Stand-alone identification variables in the
SELECT clause may optionally be
qualified by the OBJECT operator. |
| OrderByClauseStateObject |
The
ORDER BY clause allows the objects or values that are returned by the
query to be ordered. |
| OrderByItemStateObject |
An
ORDER BY 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. |
| OrExpressionStateObject |
The
OR logical operator chains multiple criteria together. |
| RangeVariableDeclarationStateObject |
Range variable declarations allow the developer to designate a "root" for objects which may not
be reachable by navigation.
|
| ResultVariableStateObject |
A result variable may be used to name a select item in the query result.
|
| SelectClauseStateObject |
The
SELECT statement queries data from entities, which determines the type of
the objects or values to be selected. |
| SelectStatementStateObject |
This state object represents a select statement, which has at least a
SELECT
clause and a FROM clause. |
| SimpleFromClauseStateObject |
The
FROM clause of a sub-query defines the domain of the sub-query by
declaring identification variables. |
| SimpleSelectClauseStateObject |
The SELECT statement queries data from entities.
|
| SimpleSelectStatementStateObject |
This state object represents a subquery, which has at least a
SELECT clause
and a FROM clause. |
| SimpleStateObject |
This
StateObject simply holds onto a string. |
| SizeExpressionStateObject |
The
SIZE function returns an integer value, the number of elements of the
collection. |
| SqrtExpressionStateObject |
The
SQRT function takes a numeric argument and returns a Double. |
| StateFieldPathExpressionStateObject |
A single-valued association field is designated by the name of an association-field in a
one-to-one or many-to-one relationship.
|
| StateFieldPathExpressionStateObject.MapManagedType | |
| StringLiteralStateObject |
A string literal is enclosed in single quotes.
|
| SubExpressionStateObject |
This expression wraps a sub-expression within parenthesis.
|
| SubstringExpressionStateObject |
The second and third arguments of the
SUBSTRING function denote the starting
position and length of the substring to be returned. |
| SubtractionExpressionStateObject |
TODO:
BNF:
arithmetic_expression ::= arithmetic_expression - arithmetic_term |
| SumFunctionStateObject |
One of the aggregate functions.
|
| TreatExpressionStateObject |
Returns an expression that allows to treat its base as if it were a subclass of the class
returned by the base.
|
| TrimExpressionStateObject |
The
TRIM function trims the specified character from a string. |
| TypeExpressionStateObject |
An entity type expression can be used to restrict query polymorphism.
|
| UnknownExpressionStateObject |
This
StateObject holds onto an unknown portion of a JPQL query that could not be parsed. |
| UpdateClauseStateObject |
This is the
UPDATE clause of the UPDATE statement. |
| UpdateItemStateObject |
The
new_value specified for an update operation must be compatible in type with the
field to which it is assigned. |
| UpdateStatementStateObject |
The
UPDATE clause of a query consists of a conditional expression used to
select objects or values that satisfy the expression. |
| UpperExpressionStateObject |
The
UPPER function converts a string to upper case and it returns a string. |
| ValueExpressionStateObject |
This object represents an identification variable that maps the values of a
Map. |
| WhenClauseStateObject |
A
WHEN predicate is used to calculate a condition and when it's true, its
THEN will be executed. |
| WhereClauseStateObject |
The
WHERE clause of a query consists of a conditional expression used to
select objects or values that satisfy the expression. |
StateObject classes that represents a JPQL query.