Package org.eclipse.persistence.jpa.jpql.parser

This is the core of Hermes, this package contains the classes that can parse a JPQL query.

See:
Description

Interface Summary

EclipseLinkExpressionVisitor	The ExpressionVisitor that adds support for the additional JPQL identifiers supported by EclipseLink that is not defined in the JPA function specification.
Expression	This is the root interface of the parsed tree representation of a JPQL query.
ExpressionVisitor	The interface is used to traverse the JPQL parsed tree.
JPQLGrammar	A JPQL grammar defines how a JPQL query can be parsed.

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.

AbstractEclipseLinkExpressionVisitor

The abstract implementation of EclipseLinkExpressionVisitor.

AbstractEclipseLinkTraverseChildrenVisitor

This ExpressionVisitor traverses the entire hierarchy of the JPQL parsed tree by going down into each of the children of any given Expression.

AbstractEclipseLinkTraverseParentVisitor

This EclipseLinkExpressionVisitor traverses up the hierarchy.

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.

AbstractJPQLGrammar

The abstract definition of a JPQLGrammar.

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

One of the four binary operators.

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

The AND logical operator chains multiple criteria together.

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

This wraps another Expression that was correctly parsed by it is located in an invalid location within the JPQL query.

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.

CastExpression

The CAST function cast value to a different type.

CastExpressionBNF

The query BNF for the CAST function.

CastExpressionFactory

This CastExpressionFactory creates a new CastExpression when the portion of the query to parse starts with CAST.

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.

DatabaseType

This expression represents the database specific data type, which may include size and scale.

DatabaseTypeFactory

DatabaseTypeQueryBNF

The query BNF for the database type.

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.

DefaultEclipseLinkJPQLGrammar

This JPQL grammar provides support for parsing JPQL queries defined by the JPA 2.1 functional specification and the EclipseLink 2.4.

DefaultJPQLGrammar

This JPQL grammar provides support for parsing JPQL queries defined in the latest JPA functional specification.

DefaultStringExpression

An implementation of an Expression 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

One of the four binary operators.

EclipseLinkAnonymousExpressionVisitor

This visitor allows a subclass to simply override AnonymousExpressionVisitor.visit(Expression) and perform the same task for all visited expressions including those defined by EclipseLink.

EclipseLinkJPQLGrammar1

This JPQL grammar provides support for parsing JPQL queries defined in

EclipseLinkJPQLGrammar2_0

This JPQLGrammar provides support for parsing JPQL queries defined in

EclipseLinkJPQLGrammar2_1

This JPQLGrammar provides support for parsing JPQL queries defined in

EclipseLinkJPQLGrammar2_2

This JPQLGrammar provides support for parsing JPQL queries defined in

EclipseLinkJPQLGrammar2_3

This JPQLGrammar provides support for parsing JPQL queries defined in

EclipseLinkJPQLGrammar2_4

This JPQLGrammar provides support for parsing JPQL queries defined in

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).

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 contains the necessary information used by Hermes parser.

ExpressionVisitorWrapper

This ExpressionVisitor wraps another ExpressionVisitor and delegates all its calls to it (the delegate).

ExtractExpression

The EXTRACT function extracts a date part from a date/time value.

ExtractExpressionBNF

The query BNF for the EXTRACT function.

ExtractExpressionFactory

This ExtractExpressionFactory creates a new ExtractExpression when the portion of the query to parse starts with EXTRACT.

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 a "virtual" identification variable if the range variable declaration does not define one.

FunctionExpression

This expression adds support to call native database functions.

FunctionExpressionBNF

The query BNF for the EclipseLink's function expression.

FunctionExpressionFactory

This FunctionExpressionFactory creates a new FunctionExpression when the portion of the query to parse starts with an identifier related to a SQL function.

FunctionItemBNF

The query BNF for the parameters of a function 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.

GenericQueryBNF

A generic JPQLQueryBNF can be used to manually create a new BNF without having to create a concrete instance.

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 handles parsing the JPQL fragment within the FROM clause.

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

The query BNF describes the expression being tested by the IN expression.

InExpressionFactory

This InExpressionFactory creates a new InExpression when the portion of the query to parse starts with IN or NOT IN.

InExpressionItemBNF

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.

InternalAggregateFunctionBNF

The query BNF for the parameter of an aggregate expression.

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.

InternalColumnExpressionBNF

The query BNF for the items of a COLUMN 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, basically what follows the FROM identifier.

InternalJoinBNF

The query BNF for what's following the join identifier.

InternalLengthExpressionBNF

The query BNF for the parameter of the LENGTH expression.

InternalLocateStringExpressionBNF

The query BNF for the first two parameters of the LOCATE expression.

InternalLocateThirdExpressionBNF

The query BNF for the third parameter of the LOCATE expression.

InternalLowerExpressionBNF

The query BNF for the parameter of the LOWER expression.

InternalModExpressionBNF

The query BNF for the parameters of the MOD expression.

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.

InternalSelectExpressionBNF

InternalSimpleFromClauseBNF

The query BNF for the from declaration used in a subquery.

InternalSimpleSelectExpressionBNF

InternalSqrtExpressionBNF

The query BNF for the parameter of the SQRT expression.

InternalSubstringPositionExpressionBNF

The query BNF for the position parameters of the SUBSTRING expression.

InternalSubstringStringExpressionBNF

The query BNF for the parameter of the LENGTH expression.

InternalUpdateClauseBNF

The query BNF for what's following the update identifier.

InternalUpperExpressionBNF

The query BNF for the parameter of the UPPER expression.

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.

JoinCollectionValuedPathExpressionFactory

This factory is used by EclipseLink 2.4 to add support for parsing an abstract schema name when the expression is not a join association path expression.

JoinFactory

This JoinFactory creates a new Join when the portion of the query to parse starts with JOIN or FETCH JOIN, respectively.

JoinFetchBNF

The query BNF for the fetch join expression.

JPQLExpression

A JPQLExpression is the root of the parsed tree representation of a JPQL query.

JPQLGrammar1_0

This JPQLGrammar provides support for parsing JPQL queries defined in

JPQLGrammar2_0

This JPQLGrammar provides support for parsing JPQL queries defined in

JPQLGrammar2_1

This JPQLGrammar provides support for parsing JPQL queries defined in

JPQLQueryBNF

This defines a single Backus-Naur Form (BNF) of the JPQL grammar.

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.

LikeExpressionEscapeCharacterBNF

This BNF is used when parsing an invalid fragment or to extend the default grammar.

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

One of the four binary operators.

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, which allows operations to be performed without doing a null check first.

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.

OnClause

Returns an expression that allows a join ON clause to be defined.

OnClauseBNF

The query BNF for the on clause.

OnClauseFactory

This OnClauseFactory creates a new OnClause when the portion of the query to parse starts with ON.

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

The OR logical operator chains multiple criteria together.

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.

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.

RangeDeclarationBNF

RangeDeclarationFactory

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.

RegexpExpression

The REGEXP condition is used to specify a search for a pattern.

RegexpExpressionBNF

The query BNF for a REGEXP expression.

RegexpExpressionFactory

This RegexpExpressionFactory creates a new RegexpExpression when the portion of the query to parse starts with REGEXP.

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.

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.

SimpleResultVariableBNF

The query BNF for a result variable expression.

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.

SimpleSelectExpressionBNF2_0

The query BNF for a select item expression.

SimpleSelectItemBNF

The query BNF for a select item 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.

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

This StringLiteralFactory is 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

One of the four binary operators.

SumFunction

One of the aggregate functions.

SumFunctionFactory

This SumFunctionFactory creates a new SumFunction when the portion of the query to parse starts with SUM.

TableExpression

Defines a table expression.

TableExpressionBNF

The query BNF for a table expression.

TableExpressionFactory

This TableExpressionFactory creates a new TableExpression.

TableVariableDeclaration

Defines a table expression.

TableVariableDeclarationBNF

The query BNF for a table declaration.

TableVariableDeclarationFactory

This TableVariableDeclarationFactory creates a new TableVariableDeclaration.

TreatExpression

Returns an expression that allows to treat its base as if it were a subclass of the class returned by the base.

TreatExpressionBNF

The query BNF for a TREAT expression.

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.

UnionClause

The UNION clause allows the results of two queries to be combined.

UnionClauseBNF

The query BNF for the order by clause.

UnionClauseFactory

This UnionClauseFactory creates a new UnionClause when the portion of the query to parse starts with UNION, INTERSECT or EXCEPT.

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 UPDATE 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.

VirtualJPQLQueryBNF

This JPQLQueryBNF can be used as a virtual BNF, which can wrap another BNF or BNFs and modify the default behavior.

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

FunctionExpressionFactory.ParameterCount	The number of parameters a FunctionExpression can have.
IdentifierRole	A role describes the purpose of the JPQL identifier.
OrderByItem.NullOrdering	This enumeration lists all the possible choices for ordering nulls in an item.
OrderByItem.Ordering	This enumeration lists all the possible choices for ordering an item.
TrimExpression.Specification	The possible ways to trim the string.

Package org.eclipse.persistence.jpa.jpql.parser Description

This is the core of Hermes, this package contains the classes that can parse a JPQL query.