|
Oracle Fusion Middleware Java API Reference for Oracle TopLink 11g Release 1 (11.1.1) E28847-01 |
||||||||
PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
Interface Summary | |
---|---|
Expression | This is the root interface of the Java Persistence query parsed tree. |
ExpressionVisitor | The interface is used to traverse the JPQL parsed tree. |
Class Summary | |||
---|---|---|---|
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. | ||
AbsExpressionFactory | This AbsExpressionFactory creates a new AbsExpression when the portion of the query to parse starts with ABS. |
||
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. | ||
AbstractDoubleEncapsulatedExpression | This Expression takes care of parsing an expression that encapsulates two expressions separated by a comma. |
||
AbstractEncapsulatedExpression | This expression handles parsing the identifier followed by an expression encapsulated within parenthesis. | ||
AbstractExpression | This is the abstract definition of all the parts used to create the tree hierarchy representing the parsed JPQL query. | ||
AbstractExpressionVisitor | The abstract definition of ExpressionVisitor , which implements all the methods but does nothing. |
||
AbstractFromClause | The FROM clause of a query defines the domain of the query by declaring identification variables. | ||
AbstractLiteralExpressionFactory | This factory is responsible to return the right literal expression. | ||
AbstractPathExpression | An identification variable followed by the navigation operator (.) and a state field or association field is a path expression. | ||
AbstractSchemaName | An abstract schema name designates the abstract schema type over which the query ranges. | ||
AbstractSchemaNameBNF | The query BNF for an abstract schema name. | ||
AbstractSchemaNameFactory | This AbstractSchemaNameFactory creates a new AbstractSchemaName . |
||
AbstractSelectClause | The SELECT clause denotes the query result. | ||
AbstractSelectStatement | A select statement must always have a SELECT and a FROM clause. | ||
AbstractSingleEncapsulatedExpression | This expression handles parsing a JPQL identifier followed by an expression encapsulated within parenthesis. | ||
AbstractTraverseChildrenVisitor | This ExpressionVisitor traverses the entire hierarchy of the JPQL parsed tree by going down into each of the children of any given Expression . |
||
AbstractTraverseParentVisitor | This ExpressionVisitor traverses up the hierarchy. |
||
AbstractTripleEncapsulatedExpression | This Expression takes care of parsing an expression that encapsulates three expressions separated by a comma. |
||
AdditionExpression |
BNF:
arithmetic_expression ::= arithmetic_expression + arithmetic_term |
||
AggregateExpressionBNF | The query BNF for an aggregate expression. | ||
AggregateFunction | In the SELECT clause the result of a query may be the result of an aggregate function applied to a path expression. | ||
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. |
||
AllOrAnyExpressionBNF | The query BNF for an all or any expression. | ||
AllOrAnyExpressionFactory | This AllOrAnyExpressionFactory creates a new AllOrAnyExpression when the portion of the query to parse starts with ALL, ANY or SOME. |
||
AndExpression |
BNF:
conditional_term ::= conditional_term AND conditional_factor |
||
AndExpressionFactory | This AndExpression creates a new AdditionExpression when the portion of the query to parse starts with AND. |
||
AnonymousExpressionVisitor | This visitor allows a subclass to simply override AnonymousExpressionVisitor.visit(Expression) and perform the same task for all visited expressions . |
||
ArithmeticExpression | This expression represents an arithmetic expression, which means the first and second expressions are aggregated with an arithmetic sign. | ||
ArithmeticExpressionBNF | The query BNF for an arithmetic expression. | ||
ArithmeticExpressionFactory | This ExpressionFactory creates a new expression when the portion of the query to parse starts with an arithmetic identifier. |
||
ArithmeticFactor | This expression simply adds a plus or minus sign to the arithmetic primary expression. | ||
ArithmeticFactorBNF | The query BNF for an arithmetic factor expression. | ||
ArithmeticPrimaryBNF | The query BNF for an arithmetic primary expression. | ||
ArithmeticTermBNF | The query BNF for an arithmetic term expression. | ||
AvgFunction | One of the aggregate functions. | ||
AvgFunctionFactory | This AvgFunctionFactory creates a new AvgFunction when the portion of the query to parse starts with AVG. |
||
BadExpression | |||
BadExpressionBNF | The query BNF used for an expression that is invalid. | ||
BadExpressionFactory | This BadExpressionFactory creates a new BadExpression when the portion of the query to parse is malformed. |
||
BetweenExpression | Used in conditional expression to determine whether the result of an expression falls within an inclusive range of values. | ||
BetweenExpressionBNF | The query BNF for the between expression. | ||
BetweenExpressionFactory | This BetweenExpressionFactory creates a new BetweenExpression when the portion of the query to parse starts with BETWEEN or NOT BETWEEN. |
||
BooleanExpressionBNF | The query BNF for a boolean expression. | ||
BooleanLiteralBNF | The query BNF for a boolean literal expression. | ||
BooleanPrimaryBNF | The query BNF for a boolean primary expression. | ||
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 |
||
CaseExpressionBNF | The query BNF for a case expression. | ||
CaseExpressionFactory | This CaseExpressionFactory creates a new CaseExpression when the portion of the query to parse starts with CASE. |
||
CaseOperandBNF | The query BNF for the case operand specified in the case expression. | ||
CoalesceExpression | A COALESCE expression returns null if all its arguments evaluate to null , and the value of the first non-null argument otherwise. |
||
CoalesceExpressionBNF | The query BNF for a coalesce expression. | ||
CoalesceExpressionFactory | This CoalesceExpressionFactory creates a new CoalesceExpression when the portion of the query to parse starts with COALESCE. |
||
CollectionExpression | A CollectionExpression wraps many expression which they are separated by spaces and/or commas. |
||
CollectionMemberDeclaration | An identification variable declared by a collection member declaration ranges over values of a collection obtained by navigation using a path expression. | ||
CollectionMemberDeclarationBNF | The query BNF for a collection member declaration expression. | ||
CollectionMemberDeclarationFactory | This CollectionMemberDeclarationFactory creates a new CollectionMemberDeclaration when the portion of the query to parse starts with IN. |
||
CollectionMemberExpression | This expression tests whether the designated value is a member of the collection specified by the collection-valued path expression. | ||
CollectionMemberExpressionBNF | The query BNF for a collection member expression. | ||
CollectionMemberExpressionFactory | This CollectionMemberExpressionFactory creates a new CollectionMemberExpression when the portion of the query to parse starts with MEMBER, MEMBER OF, NOT MEMBER or NOT MEMBER OF. |
||
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. |
||
CollectionValuedPathExpressionBNF | The query BNF for a collection-valued path expression. | ||
CollectionValuedPathExpressionFactory | This CollectionValuedPathExpressionFactory creates a new CollectionValuedPathExpression . |
||
ComparisonExpression | Only the values of like types are permitted to be compared. | ||
ComparisonExpressionBNF | The query BNF for a comparison expression. | ||
ComparisonExpressionFactory | This ComparisonExpressionFactory creates a new ComparisonExpression when the portion of the query to parse starts with <, >, <>, <=, >= or =. |
||
CompoundExpression | A compound expression has a left and right expressions combined by an identifier. | ||
ConcatExpression | The CONCAT function returns a string that is a concatenation of its arguments. | ||
ConcatExpressionFactory | This ConcatExpressionFactory creates a new ConcatExpression when the portion of the query to parse starts with CONCAT. |
||
ConditionalExpressionBNF | The query BNF for a conditional expression. | ||
ConditionalFactorBNF | The query BNF for a conditional factor expression. | ||
ConditionalPrimaryBNF | The query BNF for a conditional primary expression. | ||
ConditionalTermBNF | The query BNF for a conditional term expression. | ||
ConstructorExpression | In the SELECT clause a constructor may be used in the SELECT list to return one or more Java instances. | ||
ConstructorExpressionBNF | The query BNF for a constructor expression. | ||
ConstructorExpressionFactory | This ConstructorExpressionFactory creates a new ConstructorExpression when the portion of the query to parse starts with NEW. |
||
ConstructorItemBNF | The query BNF for a constructor item expression. | ||
CountFunction | One of the aggregate functions. | ||
CountFunctionFactory | This CountFunctionFactory creates a new CountFunction when the portion of the query to parse starts with COUNT. |
||
DateTime | This Expression represents a date or time. |
||
DatetimeExpressionBNF | The query BNF for a date/time expression. | ||
DateTimeFactory | This DateTimeFactory creates a new DateTime when the portion of the query to parse starts with CURRENT_DATE, CURRENT_TIME, CURRENT_TIMESTAMP or with the JDBC escape format used for date/time/timestamp. |
||
DateTimePrimaryBNF | The query BNF for a date/time primary expression. | ||
DateTimeTimestampLiteralBNF | The query BNF for a date/time/timestamp expression. | ||
DefaultStringExpression | The default implementation of a StringExpression that wraps a string. |
||
DeleteClause | This is the delete clause of the delete statement. | ||
DeleteClauseBNF | The query BNF for the delete clause. | ||
DeleteClauseFactory | This DeleteClauseFactory creates a new DeleteClause when the portion of the query to parse starts with DELETE FROM. |
||
DeleteClauseRangeVariableDeclarationBNF | The query BNF for a range variable declaration expression used by the DELETE clause, which accepts collection and aggregate expression, which is used by invalid queries. | ||
DeleteStatement | Bulk delete operation apply to entities of a single entity class (together with its subclasses, if any). | ||
DeleteStatementBNF | The query BNF for the delete statement. | ||
DeleteStatementFactory | This DeleteStatementFactory creates a new DeleteStatement when the portion of the query to parse starts with DELETE FROM. |
||
DerivedCollectionMemberDeclarationBNF | The query BNF for a derived collection member declaration expression. | ||
DivisionExpression |
BNF:
arithmetic_expression ::= arithmetic_expression / arithmetic_term |
||
ElseExpressionBNF | The query BNF for a else expression specified in the case expression. | ||
EmptyCollectionComparisonExpression | This expression tests whether or not the collection designated by the collection-valued path expression is empty (i.e, has no elements). | ||
EmptyCollectionComparisonExpression.StateFieldPathToCollectionValuedPathConverter | This visitor converts a StateFieldPathExpression into a CollectionValuedPathExpression . |
||
EmptyCollectionComparisonExpressionBNF | The query BNF for an empty collection comparison expression. | ||
EmptyCollectionComparisonExpressionFactory | This EmptyCollectionComparisonExpressionFactory creates a new EmptyCollectionComparisonExpression when the portion of the query to parse starts with IS EMPTY or IS NOT EMPTY. |
||
EncapsulatedIdentificationVariableExpression | This Expression represents an identification variable that maps a Map property, either the key, the value or a Map.Entry ). |
||
EntityExpressionBNF | The query BNF for a entity expression. | ||
EntityOrValueExpressionBNF | The query BNF for a entity or value expression. | ||
EntityTypeExpressionBNF | The query BNF for the TYPE expression. | ||
EntityTypeLiteral | This Expression wraps the name of an entity type. |
||
EntityTypeLiteralBNF | The query BNF for the entity type literal. | ||
EntityTypeLiteralFactory | This factory creates an EntityTypeLiteral , which wraps an entity name. |
||
EntryExpression | This is part of JPA 2.0. | ||
EntryExpressionFactory | This EntryExpressionFactory creates a new EntryExpression when the portion of the query to parse starts with ENTRY. |
||
EnumExpressionBNF | The query BNF for a enum expression. | ||
EnumLiteralBNF | The query BNF for an enumeration constant expression. | ||
EnumPrimaryBNF | The query BNF for an enum primary expression. | ||
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. |
||
ExistsExpressionBNF | The query BNF for the exists expression. | ||
ExistsExpressionFactory | This ExistsExpressionFactory creates a new ExistsExpression when the portion of the query to parse starts with EXISTS. |
||
ExpressionFactory | An ExpressionFactory is responsible to parse a portion of JPQL query that starts with one of the factory's identifiers. |
||
ExpressionRegistry | This registry initializes the singleton instances of various API required for parsing a JPQL query. | ||
ExpressionVisitorWrapper | This ExpressionVisitor wraps another ExpressionVisitor and delegates all its calls to it (the delegate). |
||
FromClause | The FROM clause of a query defines the domain of the query by declaring identification variables. | ||
FromClauseBNF | The query BNF for the from clause. | ||
FromClauseFactory | This FromClauseFactory creates a new FromClause when the portion of the query to parse starts with FROM. |
||
FullyQualifyPathExpressionVisitor | This visitor makes sure that all path expressions are fully qualified with the identification variable in the range variable declaration. | ||
FuncExpression | This expression adds support to call native database functions. | ||
FuncExpressionBNF | The query BNF for the EclipseLink's func expression. | ||
FuncExpressionFactory | This FuncExpressionFactory creates a new FuncExpression when the portion of the query to parse starts with FUNC. |
||
FuncItemBNF | The query BNF for the parameters of a func expression. | ||
FunctionsReturningDatetimeBNF | The query BNF for a function expression returning a date/time value. | ||
FunctionsReturningNumericsBNF | The query BNF for a function expression returning a numeric value. | ||
FunctionsReturningStringsBNF | The query BNF for a function expression returning a string value. | ||
GeneralCaseExpressionBNF | The query BNF for a general case expression. | ||
GeneralIdentificationExpressionFactory | This ValueExpressionFactory creates a general identification variable, which is either with the identifier KEY or VALUE and then checks the existence of a path expression. |
||
GeneralIdentificationVariableBNF | The query BNF for a general identification variable expression. | ||
GroupByClause | The GROUP BY construct enables the aggregation of values according to the properties of an entity class. | ||
GroupByClauseBNF | The query BNF for the group by clause. | ||
GroupByClauseFactory | This GroupByClauseFactory creates a new GroupByClause when the portion of the query to parse starts with GROUP BY. |
||
GroupByItemBNF | The query BNF for a group by item expression. | ||
GroupByItemFactory | This GroupByItemFactory is responsible to return the right expression and to support invalid expression as well. |
||
HavingClause | The HAVING construct enables conditions to be specified that further restrict the query result as restrictions upon the groups. | ||
HavingClauseBNF | The query BNF for the having clause. | ||
HavingClauseFactory | This HavingClauseFactory creates a new HavingClause when the portion of the query to parse starts with HAVING. |
||
IdentificationVariable | An identification variable is a valid identifier declared in the FROM clause of a query. | ||
IdentificationVariableBNF | The query BNF for an identification variable expression. | ||
IdentificationVariableDeclaration | An identification variable is a valid identifier declared in the FROM clause of a query. | ||
IdentificationVariableDeclarationBNF | The query BNF for an identification variable declaration expression. | ||
IdentificationVariableDeclarationFactory | This IdentificationVariableDeclarationFactory is meant to handle the parsing of a portion of the query when it's expected to be an identification variable declaration. |
||
IdentificationVariableFactory | This IdentificationVariableFactory creates a new IdentificationVariable . |
||
IndexExpression | The INDEX function returns an integer value corresponding to the position of its argument in an ordered list. | ||
IndexExpressionFactory | This IndexExpressionFactory creates a new IndexExpression when the portion of the query to parse starts with INDEX. |
||
InExpression | The state_field_path_expression must have a string, numeric, or enum value. |
||
InExpressionBNF | The query BNF for an in expression. | ||
InExpressionExpressionBNF | |||
InExpressionFactory | This InExpressionFactory creates a new InExpression when the portion of the query to parse starts with IN or NOT IN. |
||
InItemBNF | The query BNF for the items of an IN expression. | ||
InputParameter | Either positional or named parameters may be used. | ||
InputParameterBNF | The query BNF for a input parameter. | ||
InternalBetweenExpressionBNF | The query BNF for the lower and upper expressions defined in the between expression. | ||
InternalCoalesceExpressionBNF | The query BNF for the parameters defined in the coalesce expression. | ||
InternalConcatExpressionBNF | The query BNF for the COUNT expression's encapsulated expressions. | ||
InternalCountBNF | The query BNF for the parameter of the COUNT function. | ||
InternalEntityTypeExpressionBNF | The query BNF for the parameters defined in the type expression. | ||
InternalFromClauseBNF | The query BNF for the from declaration. | ||
InternalJoinBNF | The query BNF for what's following the join identifier. | ||
InternalOrderByClauseBNF | The query BNF for what's following the order by identifier. | ||
InternalOrderByItemBNF | The query BNF for an order by item. | ||
InternalOrderByItemFactory | This InternalOrderByItemFactory creates either a StateFieldPathExpression or an IdentificationVariable . |
||
InternalSimpleFromClauseBNF | The query BNF for the from declaration used in a subquery. | ||
InternalUpdateClauseBNF | The query BNF for what's following the update identifier. | ||
InternalWhenClauseBNF | The query BNF for the expression following the WHEN identifier. | ||
IsExpressionFactory | This IsExpressionFactory creates a new expression when the portion of the query to parse starts with IS. |
||
Join | A JOIN enables the fetching of an association as a side effect of the execution of a query. | ||
JoinAssociationPathExpressionBNF | The query BNF for a join association path expression. | ||
JoinBNF | The query BNF for the join expression. | ||
JoinFactory | This JoinFactory creates a new Join or FetchJoin when the portion of the query to parse starts with JOIN or FETCH JOIN, respectively. |
||
JoinFetch | A JOIN FETCH enables the fetching of an association as a side effect of the execution of a query. | ||
JoinFetchBNF | The query BNF for the fetch join expression. | ||
JPQLExpression | A JPQL expression is the parsed tree representation of a Java Persistence query. | ||
JPQLQueryBNF | This defines the Backus-Naur Form (BNF) of the | JPQLStatementBNF | The query BNF for the JPQL expression. |
KeyExpression | This is part of JPA 2.0. | ||
KeyExpressionFactory | This KeyExpressionFactory creates a new KeyExpression when the portion of the query to parse starts with KEY. |
||
KeywordExpression | The expression representing some keywords: TRUE , FALSE or NULL . |
||
KeywordExpressionFactory | This KeywordExpressionFactory creates a new KeywordExpression when the portion of the query to parse starts with FALSE, TRUE or NULL. |
||
LengthExpression | The LENGTH function returns the length of the string in characters as an integer. | ||
LengthExpressionFactory | This LengthExpressionFactory creates a new LengthExpression when the portion of the query to parse starts with LENGTH. |
||
LikeExpression | The LIKE condition is used to specify a search for a pattern. | ||
LikeExpressionBNF | The query BNF for a expression. | ||
LikeExpressionFactory | This LikeExpressionFactory creates a new LikeExpression when the portion of the query to parse starts with LIKE or NOT LIKE. |
||
LiteralBNF | The query BNF for literals, which is based on the listing defined in section 4.6.1 of the Java Specification document for JPA 2.0. | ||
LiteralExpressionFactory | This LiteralExpressionFactory is responsible to return the right literal expression. |
||
LocateExpression | The LOCATE function returns the position of a given string within a string, starting the search at a specified position. | ||
LocateExpressionFactory | This LocateExpressionFactory creates a new LocateExpression when the portion of the query to parse starts with LOCATE. |
||
LogicalExpression | This expression represents a logical expression, which means the first and second expressions are aggregated with either AND or OR. | ||
LowerExpression | The LOWER function converts a string to lower case and it returns a string. | ||
LowerExpressionFactory | This LowerExpressionFactory creates a new LowerExpression when the portion of the query to parse starts with LOWER. |
||
MaxFunction | One of the aggregate functions. | ||
MaxFunctionFactory | This MaxFunctionFactory creates a new MaxFunction when the portion of the query to parse starts with MAX. |
||
MinFunction | One of the aggregate functions. | ||
MinFunctionFactory | This MinFunctionFactory creates a new MinFunction when the portion of the query to parse starts with MIN. |
||
ModExpression | The modulo operation finds the remainder of division of one number by another. | ||
ModExpressionFactory | This ModExpressionFactory creates a new ModExpression when the portion of the query to parse starts with MOD. |
||
MultiplicationExpression |
BNF:
arithmetic_expression ::= arithmetic_expression * arithmetic_term |
||
NewValueBNF | The query BNF for a new value expression. | ||
NotExpression |
BNF:
expression ::= NOT conditional_primary |
||
NotExpressionFactory | This NotExpressionFactory creates a new NotExpression when the portion of the query to parse starts with NOT. |
||
NullComparisonExpression | A null comparison tests whether or not the single-valued path expression or input parameter is a NULL value. | ||
NullComparisonExpressionBNF | The query BNF for a null comparison expression. | ||
NullComparisonExpressionFactory | This NullComparisonExpressionFactory creates a new NullComparisonExpression when the portion of the query to parse starts with IS NULL or IS NOT NULL. |
||
NullExpression | A null Expression is used instead of a true null , allowing operations to be performed without doing a null check. |
||
NullIfExpression | NULLIF returns the first expression if the two expressions are not equal. | ||
NullIfExpressionBNF | The query BNF for a nullif expression. | ||
NullIfExpressionFactory | This NullIfExpressionFactory creates a new NullIfExpression when the portion of the query to parse starts with NULLIF. |
||
NumericLiteral | Exact numeric literals support the use of Java integer literal syntax as well as SQL exact numeric literal syntax. | ||
NumericLiteralBNF | The query BNF for a numeric literal. | ||
ObjectExpression | Stand-alone identification variables in the SELECT clause may optionally be qualified by the OBJECT operator. | ||
ObjectExpressionBNF | The query BNF for an object expression. | ||
ObjectExpressionFactory | This ObjectExpressionFactory creates a new ObjectExpression when the portion of the query to parse starts with OBJECT. |
||
OrderByClause | The ORDER BY clause allows the objects or values that are returned by the query to be ordered. | ||
OrderByClauseBNF | The query BNF for the order by clause. | ||
OrderByClauseFactory | This OrderByClauseFactory creates a new OrderByClause when the portion of the query to parse starts with ORDER BY. |
||
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. |
||
OrderByItemBNF | The query BNF for the order by item expression. | ||
OrderByItemFactory | This OrderByItemFactory creates a new OrderByItem . |
||
OrExpression |
BNF:
conditional_expression ::= conditional_expression OR conditional_term |
||
OrExpressionFactory | This OrExpressionFactory creates a new OrExpression when the portion of the query to parse starts with OR. |
||
PatternValueBNF | The query BNF for a pattern value. | ||
PreLiteralExpressionBNF | The query BNF used to access PreLiteralExpressionFactory . |
||
PreLiteralExpressionFactory | This PreLiteralExpressionFactory is used to verify the next word in the query is not an identifier before delegating the creation to LiteralExpressionFactory . |
||
QualifiedIdentificationVariableBNF | The query BNF for a qualified identification variable expression. | ||
QueryPosition | This object contains the cursor position within the parsed tree and within each of the Expression from the root to the deepest leaf. |
||
RangeVariableDeclaration | Range variable declarations allow the developer to designate a "root" for objects which may not be reachable by navigation. | ||
RangeVariableDeclarationBNF | The query BNF for a range variable declaration expression. | ||
RangeVariableDeclarationFactory | This RangeVariableDeclaration creates a new RangeVariableDeclaration . |
||
ResultVariable | A result variable may be used to name a select item in the query result. | ||
ResultVariableBNF | The query BNF for a result variable expression. | ||
ResultVariableFactory | This ResultVariableFactory creates a new ResultVariable when the portion of the query to parse starts with or without AS. |
||
ScalarExpressionBNF | The query BNF for a scalar expression. | ||
SelectClause | The SELECT clause queries data from entities. | ||
SelectClauseBNF | The query BNF for the select clause. | ||
SelectClauseFactory | This SelectClauseFactory creates a new SelectClause when the portion of the query to parse starts with SELECT. |
||
SelectExpressionBNF | The query BNF for a select expression. | ||
SelectItemBNF | The query BNF for a select item expression. | ||
SelectStatement | A select statement must always have a SELECT and a FROM clause. | ||
SelectStatementBNF | The query BNF for the select statement. | ||
SelectStatementFactory | This SelectStatementFactory creates a new SelectStatement when the portion of the query to parse starts with SELECT. |
||
SimpleArithmeticExpressionBNF | The query BNF for a simple arithmetic expression. | ||
SimpleCaseExpressionBNF | The query BNF for a simple case expression. | ||
SimpleConditionalExpressionBNF | The query BNF for a simple conditional expression. | ||
SimpleEntityExpressionBNF | The query BNF for a simple entity expression. | ||
SimpleEntityOrValueExpressionBNF | The query BNF for a simple entity or value expression. | ||
SimpleFromClause | The FROM clause of a query defines the domain of the query by declaring identification variables. | ||
SimpleSelectClause | The SELECT statement queries data from entities. | ||
SimpleSelectClauseBNF | The query BNF for the simple select clause. | ||
SimpleSelectExpressionBNF | The query BNF for a simple select expression. | ||
SimpleSelectStatement |
BNFL
subquery ::= simple_select_clause subquery_from_clause [where_clause] [groupby_clause] [having_clause] |
||
SimpleSelectStatementFactory | This SimpleSelectStatementFactory creates a new SimpleSelectStatement when the portion of the query to parse starts with SELECT. |
||
SingleValuedObjectPathExpressionBNF | The query BNF for a simple valued object path expression. | ||
SingleValuedPathExpressionBNF | The query BNF for a single valued path expression. | ||
SizeExpression | The SIZE function returns an integer value, the number of elements of the collection. | ||
SizeExpressionFactory | This SizeExpressionFactory creates a new SizeExpression when the portion of the query to parse starts with SIZE. |
||
SqrtExpression | The SQRT function takes a numeric argument and returns a double. | ||
SqrtExpressionFactory | This SqrtExpressionFactory creates a new SqrtExpression when the portion of the query to parse starts with SQRT. |
||
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. |
||
StateFieldPathExpressionBNF | The query BNF for a state field path expression. | ||
StateFieldPathExpressionFactory | This StateFieldPathExpressionFactory is meant to handle the parsing of a portion of the query when it's expected to be a state field path. |
||
StringExpression | A StringExpression is used when retrieving the deepest Expression in the JPQL parsed tree. |
||
StringExpressionBNF | The query BNF for a string expression. | ||
StringLiteral | A string literal is enclosed in single quotes. | ||
StringLiteralBNF | The query BNF for a string literal. | ||
StringLiteralFactory | The StringLiteralExpressionFactory responsible to parse a sub-query starting with a single quote. |
||
StringPrimaryBNF | The query BNF for a string primary expression. | ||
SubExpression | This expression wraps a sub-expression within parenthesis. | ||
SubQueryBNF | The query BNF for a subquery expression. | ||
SubQueryFromClauseBNF | The query BNF for the from clause defined in a subquery. | ||
SubSelectIdentificationVariableDeclarationBNF | The query BNF for an identification variable declaration expression defined in a sub-select expression. | ||
SubstringExpression | The second and third arguments of the SUBSTRING function denote the starting position and length of the substring to be returned. | ||
SubstringExpressionFactory | This SubstringExpressionFactory creates a new SubstringExpression when the portion of the query to parse starts with SUBSTRING. |
||
SubtractionExpression |
BNF:
arithmetic_expression ::= arithmetic_expression - arithmetic_term |
||
SumFunction | One of the aggregate functions. | ||
SumFunctionFactory | This SumFunctionFactory creates a new SumFunction when the portion of the query to parse starts with SUM. |
||
TreatExpression | Returns an expression that allows to treat its base as if it were a subclass of the class returned by the base. | ||
TreatExpressionBNF | |||
TreatExpressionFactory | This TreatExpressionFactory creates a new TreatExpression when the portion of the query to parse starts with TREAT. |
||
TrimExpression | The TRIM function trims the specified character from a string. | ||
TrimExpressionFactory | This TrimExpressionFactory creates a new TrimExpression when the portion of the query to parse starts with TRIM. |
||
TypeExpression | An entity type expression can be used to restrict query polymorphism. | ||
TypeExpressionBNF | The query BNF for a type expression. | ||
TypeExpressionFactory | This TypeExpressionFactory creates a new TypeExpression when the portion of the query to parse starts with TYPE. |
||
UnknownExpression | This expression contains a portion of the query that is unknown to the parser. | ||
UnknownExpressionFactory | This UnknownExpressionFactory creates a new UnknownExpression when the portion of the query to parse is unknown. |
||
UpdateClause | This is the update clause of the update statement. | ||
UpdateClauseBNF | The query BNF for the update clause. | ||
UpdateClauseFactory | This UpdateClauseFactory creates a new UpdateClause when the portion of the query to parse starts with UPDATE. |
||
UpdateItem | The new_value specified for an update operation must be compatible in type with the field to which it is assigned. |
||
UpdateItemBNF | The query BNF for the update item expression. | ||
UpdateItemFactory | This UpdateItemFactory creates a new UpdateItem . |
||
UpdateItemStateFieldPathExpressionBNF | The query BNF for a state field path expression used in an update item. | ||
UpdateItemStateFieldPathExpressionFactory | This UpdateItemStateFieldPathExpressionFactory is meant to handle the parsing of a portion of the query when it's expected to be a state field path. |
||
UpdateStatement | The WHERE clause of a query consists of a conditional expression used to select objects or values that satisfy the expression. | ||
UpdateStatementBNF | The query BNF for the update statement. | ||
UpdateStatementFactory | This UpdateStatementFactory creates a new UpdateStatement when the portion of the query to parse starts with UPDATE. |
||
UpperExpression | The UPPER function converts a string to upper case and it returns a string. | ||
UpperExpressionFactory | This UpperExpressionFactory creates a new UpperExpression when the portion of the query to parse starts with UPPER. |
||
ValueExpression | This is part of JPA 2.0. | ||
ValueExpressionFactory | This ValueExpressionFactory creates a new ValueExpression when the portion of the query to parse starts with VALUE. |
||
WhenClause | A WHEN predicate is used to calculate a condition and when it's true, its THEN will be executed. | ||
WhenClauseBNF | The query BNF for the when clause of the case expression. | ||
WhenClauseFactory | This WhenClauseFactory creates a new WhenClause when the portion of the query to parse starts with WHEN. |
||
WhereClause | The WHERE clause of a query consists of a conditional expression used to select objects or values that satisfy the expression. | ||
WhereClauseBNF | The query BNF for the where clause. | ||
WhereClauseFactory | This WhereClauseFactory creates a new WhereClause when the portion of the query to parse starts with WHERE. |
Enum Summary | |
---|---|
CaseExpression.ParsingType | A enumeration used to determine how CaseExpression#isParsingComplete(WordParser, String) should behaves. |
IdentifierRole | A role describes the purpose of the JPQL identifier. |
OrderByItem.Ordering | This enumeration lists all the possible choices for ordering an item. |
TrimExpression.Specification | The possible ways to trim the string. |
|
|
||||||||
PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |