|
EclipseLink 2.4.2, build 'v20130514-5956486' API Reference | ||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES | ||||||||
StateObject classes that represents a JPQL query.
See:
Description
| Interface Summary | |
|---|---|
| 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 Summary | |
|---|---|
| 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. |
This package contains the StateObject classes that represents a JPQL query.
|
EclipseLink 2.4.2, build 'v20130514-5956486' API Reference | ||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES | ||||||||