All Classes

Class	Description
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.
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.
AbsFunctionResolver	This Resolver is responsible to calculate the IType based on the type of the ABS expression.
AbstractActualJPQLQueryFormatter	This IJPQLQueryFormatter is used to generate a string representation of a StateObject based on how it was parsed, which means this formatter can only be used when the StateObject was created by parsing a JPQL query because it needs to retrieve parsing information from the corresponding Expression.
AbstractCaseExpressionStateObjectBuilder	This abstract implementation of ICaseExpressionStateObjectBuilder adds support for creating a CASE expression.
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.
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.
AbstractConditionalExpressionStateObjectBuilder<T extends IAbstractConditionalExpressionStateObjectBuilder<T>>	The abstract implementation of IConditionalExpressionStateObjectBuilder that supports the creation of the conditional expression based on the JPQL grammar defined in JPA 2.0.
AbstractConditionalStateObjectBuilderWrapper	This builder wraps another builder and delegates the calls to it.
AbstractContentAssistVisitor	The visitor provides support for finding the possible proposals within a JPQL query at a certain position.
AbstractContentAssistVisitor.AbstractAppendableExpressionVisitor
AbstractContentAssistVisitor.AbstractConditionalClauseCollectionHelper<T extends Expression>	This helper handles adding proposals within a conditional expression that might be parsed as a single expression or has a collection of expression, which means the fragment is either incomplete or invalid.
AbstractContentAssistVisitor.AbstractFromClauseStatementHelper<T extends AbstractSelectStatement>
AbstractContentAssistVisitor.AbstractGroupByClauseStatementHelper<T extends AbstractSelectStatement>
AbstractContentAssistVisitor.AbstractHavingClauseStatementHelper<T extends AbstractSelectStatement>
AbstractContentAssistVisitor.AbstractSelectClauseCollectionHelper<T extends AbstractSelectClause>
AbstractContentAssistVisitor.AbstractSelectClauseStatementHelper
AbstractContentAssistVisitor.AbstractWhereClauseSelectStatementHelper<T extends AbstractSelectStatement>
AbstractContentAssistVisitor.AcceptableTypeVisitor	This visitor retrieves the permitted type from the path expression's parent.
AbstractContentAssistVisitor.AppendableExpressionVisitor	This visitor scans the visited Expression and determines if a JPQL identifier can be added ("appended") when the position of the cursor is at the end of the expression.
AbstractContentAssistVisitor.AppendableType	This is used to determine how AbstractContentAssistVisitor.AppendableExpressionVisitor should perform the check.
AbstractContentAssistVisitor.CollectionExpressionHelper<T extends Expression>	This helper is used to determine how to add proposals within a collection of expressions.
AbstractContentAssistVisitor.CollectionExpressionVisitor	This visitor retrieves the CollectionExpression if it is visited.
AbstractContentAssistVisitor.CollectionMappingFilter
AbstractContentAssistVisitor.ConcatExpressionCollectionHelper
AbstractContentAssistVisitor.ConditionalClauseCollectionHelper	This helpers handles adding proposals for AbstractConditionalClause.
AbstractContentAssistVisitor.ConstrutorCollectionHelper
AbstractContentAssistVisitor.DeclarationVisitor
AbstractContentAssistVisitor.DefaultMappingCollector	The default implementation of AbstractContentAssistVisitor.MappingCollector, which simply returns an empty collection.
AbstractContentAssistVisitor.DeleteClauseCollectionHelper
AbstractContentAssistVisitor.DeleteClauseStatementHelper
AbstractContentAssistVisitor.DifferentComparisonFilter
AbstractContentAssistVisitor.DoubleEncapsulatedCollectionHelper
AbstractContentAssistVisitor.EncapsulatedExpressionVisitor
AbstractContentAssistVisitor.EndingQueryPositionBuilder	This builder populates a QueryPosition by traversing the valid portion of the JPQL query.
AbstractContentAssistVisitor.EnumVisitor	This visitor determines whether a path expression can be resolved as a fully qualified enum type and an enum constant.
AbstractContentAssistVisitor.FilteringMappingCollector	This AbstractContentAssistVisitor.MappingCollector returns the possible mappings (non-collection type or collection type) from a managed type.
AbstractContentAssistVisitor.FollowingClausesVisitor
AbstractContentAssistVisitor.FollowingInvalidExpressionVisitor
AbstractContentAssistVisitor.FromClauseCollectionHelper
AbstractContentAssistVisitor.FromClauseStatementHelper
AbstractContentAssistVisitor.GroupByClauseCollectionHelper
AbstractContentAssistVisitor.GroupByClauseStatementHelper
AbstractContentAssistVisitor.HavingClauseStatementHelper
AbstractContentAssistVisitor.IdentificationVariableType	The various ways of retrieving identification variables from the declaration expression.
AbstractContentAssistVisitor.IncompleteCollectionExpressionVisitor	This visitor is used when a clause or a compound expression was parsed with a collection of expressions representing an invalid fragment.
AbstractContentAssistVisitor.InvalidExpressionVisitor	This visitor determines if the visited Expression is one of the two that represents an invalid expression.
AbstractContentAssistVisitor.JoinCollectionHelper
AbstractContentAssistVisitor.MappingCollector	A collector is responsible to retrieve the possible proposals by using the mappings that can complete a path expression.
AbstractContentAssistVisitor.MappingFilterBuilder	This visitor is responsible to create the right Filter based on the type of the Expression.
AbstractContentAssistVisitor.MappingTypeFilter	This Filter is responsible to filter out the mappings that can't have their type assignable to the one passed in.
AbstractContentAssistVisitor.NotExpressionVisitor
AbstractContentAssistVisitor.OrderByClauseCollectionHelper
AbstractContentAssistVisitor.OrderByClauseStatementHelper
AbstractContentAssistVisitor.PropertyMappingFilter
AbstractContentAssistVisitor.RangeVariableDeclarationVisitor
AbstractContentAssistVisitor.ResultVariableVisitor
AbstractContentAssistVisitor.SelectClauseCollectionHelper
AbstractContentAssistVisitor.SelectClauseStatementHelper
AbstractContentAssistVisitor.SimpleFromClauseStatementHelper
AbstractContentAssistVisitor.SimpleGroupByClauseStatementHelper
AbstractContentAssistVisitor.SimpleHavingClauseStatementHelper
AbstractContentAssistVisitor.SimpleSelectClauseCollectionHelper
AbstractContentAssistVisitor.SimpleSelectClauseStatementHelper
AbstractContentAssistVisitor.SimpleWhereClauseSelectStatementHelper
AbstractContentAssistVisitor.StatementHelper<T extends Expression>	This helper helps to add JPQL identifiers for the clauses that make up a query statement and also chains the clauses within the query.
AbstractContentAssistVisitor.SubqueryAppendableExpressionVisitor
AbstractContentAssistVisitor.SubqueryVisitor	This visitor determines if an Expression is in a subquery.
AbstractContentAssistVisitor.TripleEncapsulatedCollectionHelper
AbstractContentAssistVisitor.UpdateClauseStatementHelper
AbstractContentAssistVisitor.UpdateItemCollectionHelper
AbstractContentAssistVisitor.VisitParentVisitor	This visitor is meant to adjust the corrections stack when traversing an Expression in order to increase the list of valid proposals.
AbstractContentAssistVisitor.WhenClauseConditionalClauseCollectionHelper	This helpers handles adding proposals for WhenClause.
AbstractContentAssistVisitor.WhereClauseDeleteStatementHelper
AbstractContentAssistVisitor.WhereClauseSelectStatementHelper
AbstractContentAssistVisitor.WhereClauseUpdateStatementHelper
AbstractContentAssistVisitor.WithinInvalidExpressionVisitor
AbstractDoubleEncapsulatedExpression	This Expression takes care of parsing an expression that encapsulates two expressions separated by a comma.
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.
AbstractEclipseLinkExpressionVisitor	The abstract implementation of EclipseLinkExpressionVisitor.
AbstractEclipseLinkParameterTypeVisitor	This visitor calculates the type of an input parameter.
AbstractEclipseLinkSelectExpressionStateObjectBuilder
AbstractEclipseLinkSemanticValidator	This validator is responsible to gather the problems found in a JPQL query by validating the content to make sure it is semantically valid for EclipseLink.
AbstractEclipseLinkSemanticValidator.EclipseLinkOwningClauseVisitor	This visitor retrieves the clause owning the visited Expression.
AbstractEclipseLinkSemanticValidator.SubquerySelectItemCalculator
AbstractEclipseLinkSemanticValidator.TableExpressionVisitor
AbstractEclipseLinkSemanticValidator.TopLevelFirstDeclarationVisitor
AbstractEclipseLinkSimpleSelectExpressionStateObjectBuilder
AbstractEclipseLinkStateObjectVisitor	The abstract definition of EclipseLinkStateObjectVisitor, which implements all the methods but does nothing.
AbstractEclipseLinkTraverseChildrenVisitor	This ExpressionVisitor traverses the entire hierarchy of the JPQL parsed tree by going down into each of the children of any given Expression.
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 EclipseLinkExpressionVisitor traverses up the hierarchy.
AbstractEclipseLinkTraverseParentVisitor	This StateObjectVisitor traverses up the hierarchy.
AbstractEncapsulatedExpression	This expression handles parsing the identifier followed by an expression encapsulated within parenthesis.
AbstractEncapsulatedExpressionStateObject	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.
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.
AbstractGrammarValidator	The base validator responsible to gather the problems found in a JPQL query by validating it against the provided JPQL grammar.
AbstractGrammarValidator.AbstractCollectionValidator	This validate is responsible to validate the collection of Expressions: Making sure they are all separated by a comma or by a space (depending on which one is required); Making sure it does not end with a comma; There is no empty expression between two commas.
AbstractGrammarValidator.AbstractDoubleEncapsulatedExpressionHelper<T extends AbstractDoubleEncapsulatedExpression>
AbstractGrammarValidator.AbstractEncapsulatedExpressionHelper<T extends AbstractEncapsulatedExpression>	The root helper that validates any AbstractEncapsulatedExpression.
AbstractGrammarValidator.AbstractSingleEncapsulatedExpressionHelper<T extends AbstractSingleEncapsulatedExpression>	The abstract implementation of AbstractGrammarValidator.AbstractSingleEncapsulatedExpressionHelper which implements some of the methods since the behavior is the same for all subclasses of AbstractSingleEncapsulatedExpression.
AbstractGrammarValidator.AbstractTripleEncapsulatedExpressionHelper<T extends AbstractTripleEncapsulatedExpression>
AbstractGrammarValidator.CollectionExpressionVisitor	This visitor retrieves the CollectionExpression if it is visited.
AbstractGrammarValidator.CollectionSeparatedByCommaValidator	This validator validates a CollectionExpression by making sure each item is separated by a comma.
AbstractGrammarValidator.CollectionSeparatedBySpaceValidator	This validator validates a CollectionExpression by making sure each item is not separated by a comma.
AbstractGrammarValidator.ComparisonExpressionVisitor
AbstractGrammarValidator.DateTimeVisitor
AbstractGrammarValidator.NullExpressionVisitor	This visitor checks to see if the visited expression is NullExpression.
AbstractIdentificationVariableDeclarationStateObject
AbstractJPQLGrammar	The abstract definition of a JPQLGrammar.
AbstractJPQLQueryBuilder	An abstract implementation of IJPQLQueryBuilder that parses a JPQL query or any JPQL fragments and creates the StateObject representation by delegating the creation to an instance of BasicStateObjectBuilder.
AbstractJPQLQueryFormatter	The abstract definition of a IJPQLQueryFormatter, which converts an StateObject into its string representation that can be used as a real JPQL query.
AbstractJPQLQueryHelper	This helper can perform the following operations over a JPQL query: Calculates the result type of a query: AbstractJPQLQueryHelper.getResultType(); Calculates the type of an input parameter: AbstractJPQLQueryHelper.getParameterType(String). Calculates the possible choices to complete the query from a given position (used for content assist): AbstractJPQLQueryHelper.buildContentAssistProposals(int). Validates the query by introspecting it grammatically and semantically: AbstractJPQLQueryHelper.validate(), AbstractJPQLQueryHelper.validateGrammar(), AbstractJPQLQueryHelper.validateSemantic(). Refactoring support: AbstractJPQLQueryHelper.buildBasicRefactoringTool() provides support for generating the delta of the refactoring operation through a collection of TextEdit objects. AbstractJPQLQueryHelper.buildRefactoringTool() provides support for refactoring the JPQL query through the editable StateObject and once all refactoring operations have been executed, the IJPQLQueryFormatter will generate a new string representation of the JPQL query.
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.
AbstractLiteralExpressionFactory	This factory is responsible to return the right literal expression.
AbstractModifyClauseStateObject
AbstractModifyStatementStateObject	The abstract definition of a modify statement.
AbstractNewValueStateObjectBuilder
AbstractOrderByClause	An ordering clause allows the objects or values that are returned by the query to be ordered.
AbstractPathExpression	An identification variable followed by the navigation operator (.) and a state field or association field is a path expression.
AbstractPathExpressionStateObject	An identification variable followed by the navigation operator (.) and a state field or association field is a path expression.
AbstractPathResolver	This Resolver is responsible to resolve a single path of a path expression (state field path expression, singled valued object field, or a collection-valued path expression).
AbstractRangeDeclaration	The abstract definition of a range declaration, which is used to navigate to a "root" object.
AbstractRangeVariableDeclarationStateObject
AbstractRefactoringTool	The abstract definition of a refactoring
AbstractScalarExpressionStateObjectBuilder<T extends IScalarExpressionStateObjectBuilder<T>>	This abstract definition of a builder provides the support for creating expressions defined by a scalar 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.
AbstractSchemaNameStateObject	An abstract schema name designates the abstract schema type over which the query ranges.
AbstractSelectClause	The SELECT clause denotes the query result.
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.
AbstractSelectExpressionStateObjectBuilder
AbstractSelectStatement	A query is an operation that retrieves data from one or more tables or views.
AbstractSelectStatementStateObject	This state object represents the select statement, which has at least a SELECT clause and a FROM clause.
AbstractSemanticValidator	The base validator responsible to gather the problems found in a JPQL query by validating the content to make sure it is semantically valid, i.e.
AbstractSemanticValidator.CollectionValuedPathExpressionVisitor	This visitor is meant to retrieve an CollectionValuedPathExpression if the visited Expression is that object.
AbstractSemanticValidator.ComparingEntityTypeLiteralVisitor
AbstractSemanticValidator.ComparisonExpressionVisitor	This visitor compares the left and right expressions of a comparison expression and gathers information about those expressions if they are an identification variable or a path expression.
AbstractSemanticValidator.FirstDeclarationVisitor
AbstractSemanticValidator.InItemsVisitor
AbstractSemanticValidator.PathType	This enumeration allows AbstractSemanticValidator.validateStateFieldPathExpression( StateFieldPathExpression, PathType) to validate the type of the mapping and to make sure it is allowed based on its location.
AbstractSemanticValidator.StateFieldPathExpressionVisitor	This visitor is meant to retrieve an AbstractSemanticValidator.StateFieldPathExpressionVisitor if the visited Expression is that object.
AbstractSemanticValidator.SubqueryFirstDeclarationVisitor
AbstractSemanticValidator.TopLevelFirstDeclarationVisitor
AbstractSimpleSelectExpressionStateObjectBuilder	The abstract implementation of ISimpleSelectExpressionStateObjectBuilder that supports the creation of the select expression based on the JPQL grammar defined in JPA 2.0.
AbstractSingleEncapsulatedExpression	This expression handles parsing a JPQL identifier followed by an expression encapsulated within parenthesis.
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.
AbstractStateObjectBuilder	The abstract definition of a builder of a StateObject hierarchy based on a JPQL fragment that is manually created.
AbstractStateObjectVisitor	The abstract definition of StateObjectVisitor, which implements all the methods but does nothing.
AbstractTraverseChildrenVisitor	This ExpressionVisitor traverses the entire hierarchy of the JPQL parsed tree by going down into each of the children of any given Expression.
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 ExpressionVisitor traverses up the hierarchy.
AbstractTraverseParentVisitor	This StateObjectVisitor traverses up the hierarchy.
AbstractTripleEncapsulatedExpression	This Expression takes care of parsing an expression that encapsulates three expressions separated by a comma.
AbstractTripleEncapsulatedExpressionStateObject	This state object takes care of parsing an expression that encapsulates three expressions separated by a comma.
AbstractValidator	The abstract definition of a validator, which provides helper methods and visitors.
AbstractValidator.BypassChildCollectionExpressionVisitor	This visitor is responsible to traverse the children of a CollectionExpression in order to properly validate the Expression.
AbstractValidator.BypassParentSubExpressionVisitor	This visitor is responsible to traverse the parent hierarchy and to skip SubExpression if it's a parent.
AbstractValidator.ChildrenCollectorVisitor	This visitor gathers the children of a CollectionExpression or a single visited Expression.
AbstractValidator.JPQLQueryBNFValidator	This visitor validates any Expression by checking its BNF against some BNFs.
AbstractValidator.NestedArrayVisitor
AbstractValidator.OwningClauseVisitor	This visitor retrieves the clause owning the visited Expression.
AbstractValidator.OwningStatementVisitor	This visitor retrieves the statement owning the visited Expression.
AbstractValidator.SubqueryVisitor	This visitor retrieves the statement owning the visited Expression.
AdditionExpression	One of the four binary operators.
AdditionExpressionStateObject	TODO: 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.
AggregateFunctionStateObject	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.
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.
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.
AndExpressionStateObject	The AND logical operator chains multiple criteria together.
AndFilter<T>	This filter will "accept" any object that is accept by both of the specified wrapped filters.
AnonymousExpressionVisitor	This visitor allows a subclass to simply override AnonymousExpressionVisitor.visit(Expression) and perform the same task for all visited expressions.
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.
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.
ArithmeticExpressionStateObject	This expression represents an arithmetic expression, which means the first and second expressions are aggregated with an arithmetic sign.
ArithmeticFactor	This expression simply adds a plus or minus sign to the arithmetic primary expression.
ArithmeticFactorBNF	The query BNF for an arithmetic factor expression.
ArithmeticFactorStateObject	This state object simply adds a plus or minus sign to the arithmetic primary expression.
ArithmeticPrimaryBNF	The query BNF for an arithmetic primary expression.
ArithmeticTermBNF	The query BNF for an arithmetic term expression.
ArrayIterable<E>	An ArrayIterable provides an Iterable for an array of objects of type E.
ArrayIterator<E>	An ArrayIterator provides a Iterator for an array of objects.
AsOfClause	An AS OF clause is part of a flashback query, which provides ways to view past states of database objects, or to return database objects to a previous state, without using traditional point-in-time recovery.
AsOfClauseBNF	The query BNF for the AS OF clause.
AsOfClauseFactory	This AsOfClauseFactory creates a new AsOfClause when the portion of the JPQL query to parse starts with AS OF.
Assert	An utility class that provides various checks and when the condition fails, then an Assert.AssertException is thrown.
Assert.AssertException	The exception thrown when the condition is not met.
AvgFunction	One of the aggregate functions.
AvgFunctionFactory	This AvgFunctionFactory creates a new AvgFunction when the portion of the query to parse starts with AVG.
AvgFunctionStateObject	One of the aggregate functions.
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.
BadExpressionStateObject	This wraps an invalid portion of the JPQL query that could not be parsed.
BaseDeclarationIdentificationVariableFinder	This visitor traverses the parsed tree and retrieves the IdentificationVariable defined in the base range variable declaration for the top-level statement if and only if the query is a DELETE or UPDATE query.
BaseJPQLQueryFormatter	An abstract implementation of a IJPQLQueryFormatter.
BasicRefactoringTool	The abstract implementation providing refactoring support for JPQL queries.
BasicRefactoringTool.JavaQuery	A simple implementation of IQuery.
BasicStateObjectBuilder	The default implementation of a IBuilder, which creates a StateObject representation of the Expression being visited.
BasicStateObjectBuilder.CollectionExpressionVisitor
BasicStateObjectBuilder.CollectionMemberDeclarationBuilder
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.
BetweenExpressionStateObject	Used in conditional expression to determine whether the result of an expression falls within an inclusive range of values.
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.
CaseExpressionStateObject	A CASE predicate is used to calculate a condition and when it's true, its THEN expression will be executed.
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.
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).
ClassNameResolver	This Resolver simply holds onto the fully qualified class name of the IType.
ClassResolver	This Resolver simply holds onto the actual type since it is already determined.
CloneIterable<E>	Pull together remover state and behavior for subclasses.
CloneIterator<E>	A CloneIterator iterates over a copy of a collection, allowing for concurrent access to the original collection.
CloneIterator.Remover<T>	Used by CloneIterator to remove elements from the original collection; since the iterator does not have direct access to the original collection.
CloneIterator.Remover.ReadOnly<S>
CloneListIterable<E>	Pull together mutator state and behavior for subclasses.
CloneListIterator<E>	A CloneListIterator iterates over a copy of a list, allowing for concurrent access to the original list.
CloneListIterator.Mutator<T>	Used by CloneListIterator to remove elements from the original list; since the list iterator does not have direct access to the original list.
CloneListIterator.Mutator.ReadOnly<S>
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.
CoalesceExpressionStateObject	A COALESCE expression returns null if all its arguments evaluate to null, and the value of the first non-null argument otherwise.
CollectionDeclaration	This CollectionDeclaration represents a collection member declaration that was declared in the FROM clause of a SELECT top-level query or subquery.
CollectionEquivalentResolver	This Resolver compares each IType retrieved from the list of Resolvers that were gathered for a given Expression and returns that type if they are all the same type otherwise the IType for Object is returned.
CollectionExpression	A CollectionExpression wraps many expression which they are separated by spaces and/or commas.
CollectionExpressionStateObject	This StateObject is a temporary object used to store a list of StateObjects.
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.
CollectionMemberDeclarationStateObject	An identification variable declared by a collection_member_declaration ranges over values of a collection obtained by navigation using a path expression.
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.
CollectionMemberExpressionStateObject	This expression tests whether the designated value is a member of the collection specified by the collection-valued path expression.
CollectionTools	This utility class provides utility methods related to collections, iterators and arrays.
CollectionValuedFieldResolver	This Resolver is responsible to resolve the type of a collection-valued field.
CollectionValuedFieldResolver.MapManagedType
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
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.
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 =.
ComparisonExpressionStateObject	Only the values of like types are permitted to be compared.
CompoundExpression	A compound expression has a left and right expressions combined by an identifier.
CompoundExpressionStateObject	A compound StateObject has a left and right expressions combined by an identifier.
CompoundFilter<T>	This filter provides a simple framework for combining the behavior of a pair of filters.
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.
ConcatExpressionStateObject	The CONCAT function returns a string that is a concatenation of its arguments.
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.
ConnectByClause	The CONNECT BY clause allows selecting rows in a hierarchical order using the hierarchical query clause.
ConnectByClauseBNF	The query BNF for a CONNECT BY clause.
ConnectByClauseFactory	This ConnectByClauseFactory creates a new ConnectByClause when the portion of the query to parse starts with CONNECT BY.
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.
ConstructorExpressionStateObject	In the SELECT clause a constructor may be used in the SELECT list to return one or more Java instances.
ConstructorItemBNF	The query BNF for a constructor item expression.
ContentAssistExtension	This extension can be used to provide additional support to JPQL content assist that is outside the scope of providing proposals related to JPA metadata.
ContentAssistProposals	This object stores the various proposals available for content assist for a certain position within a JPQL query.
ContentAssistProposals.ClassType	This enumeration determines the type of classes returned by ContentAssistProposals.classNames().
ContentAssistProposals.EnumProposals	Holds onto the IType of the enum type and the list of possible enum constants.
CountFunction	One of the aggregate functions.
CountFunctionFactory	This CountFunctionFactory creates a new CountFunction when the portion of the query to parse starts with COUNT.
CountFunctionStateObject	One of the aggregate functions.
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.
DateTimeStateObject	This DateTimeStateObject represents a date or time.
DateTimeTimestampLiteralBNF	The query BNF for a date/time/timestamp expression.
Declaration	The abstract definition of JPQLQueryDeclaration.
DeclarationResolver	This Resolver is responsible to visit the current query (which is either the top-level query or a subquery) and gathers the information from the declaration clause.
DeclarationResolver.QualifyRangeDeclarationVisitor
DeclarationStateObject	This defines the declaration portion of a query, which is the FROM clause of a query.
DefaultActualJPQLQueryFormatter	This IJPQLQueryFormatter is used to generate a string representation of a StateObject based on how it was parsed, which means this formatter can only be used when the StateObject was created by parsing a JPQL query because it needs to retrieve parsing information from the corresponding Expression.
DefaultBasicRefactoringTool	This utility class provides basic refactoring support.
DefaultCaseExpressionStateObjectBuilder	The default implementation of a ICaseExpressionStateObjectBuilder.
DefaultConditionalExpressionStateObjectBuilder	The default implementation of IConditionalExpressionStateObjectBuilder.
DefaultContentAssistProposals	The default implementation of ContentAssistProposals which stores the valid proposals.
DefaultContentAssistVisitor	This visitor traverses the JPQL parsed tree and gathers the possible proposals at a given position.
DefaultEclipseLinkJPQLGrammar	This JPQL grammar provides support for parsing JPQL queries defined by the JPA 2.1 functional specification and the EclipseLink 2.6.
DefaultEclipseLinkJPQLQueryBuilder	An implementation of IJPQLQueryBuilder that provides support based on the latest release of the Java Persistence functional specification.
DefaultGrammarValidator	This validator is responsible to validate a JPQL query grammatically purely based on the JPA specification document.
DefaultJPQLGrammar	This JPQL grammar provides support for parsing JPQL queries defined in the latest JPA functional specification.
DefaultJPQLQueryBuilder	An implementation of IJPQLQueryBuilder that provides support based on the latest release of the Java Persistence functional specification.
DefaultJPQLQueryContext	This context is used to store information related to the JPQL query.
DefaultJPQLQueryFormatter	The default implementation of a IJPQLQueryFormatter, which support creating a string representation of a JPQL query written for JPA 1.0 and 2.0.
DefaultJPQLQueryHelper	This helper can perform the following operations over a JPQL query: Calculates the result type of a query: AbstractJPQLQueryHelper.getResultType(); Calculates the type of an input parameter: AbstractJPQLQueryHelper.getParameterType(String). Calculates the possible choices to complete the query from a given position (used for content assist): AbstractJPQLQueryHelper.buildContentAssistProposals(int). Validates the query by introspecting it grammatically and semantically: AbstractJPQLQueryHelper.validate(), AbstractJPQLQueryHelper.validateGrammar(), AbstractJPQLQueryHelper.validateSemantic(). Refactoring support: DefaultJPQLQueryHelper.buildBasicRefactoringTool() provides support for generating the delta of the refactoring operation through a collection of TextEdit objects. DefaultJPQLQueryHelper.buildRefactoringTool() provides support for refactoring the JPQL query through the editable StateObject and once all refactoring operations have been executed, the IJPQLQueryFormatter will generate a new string representation of the JPQL query. This helper should be used when the JPQL query is written using the JPQL grammar defined in the Java Persistence functional specification 1.0 or 2.x.
DefaultLiteralVisitor	This visitor traverses an Expression and retrieves the "literal" value.
DefaultNewValueStateObjectBuilder	The default implementation of INewValueStateObjectBuilder.
DefaultParameterTypeVisitor	This visitor calculates the type of an input parameter.
DefaultProblem	The default implementation of Problem.
DefaultRefactoringDelta	The default implementation of RefactoringDelta which contains the TextEdit that were creating during the refactoring of a JPQL query.
DefaultRefactoringTool	This utility class provides basic refactoring support.
DefaultResolverBuilder	The default implementation of a ResolverBuilder, which follows the JPA functional specification.
DefaultSelectExpressionStateObjectBuilder
DefaultSemanticValidator	This validator is responsible to gather the problems found in a JPQL query by validating the content to make sure it is semantically valid.
DefaultSemanticValidator.NullValueVisitor
DefaultSemanticValidator.ResultVariableInOrderByVisitor
DefaultSemanticValidator.UpdateClauseAbstractSchemaNameFinder
DefaultSimpleSelectExpressionStateObjectBuilder
DefaultStateObjectBuilder	The default implementation of BasicStateObjectBuilder, which provides support for creating a StateObject representation of any Expression.
DefaultStringExpression	An implementation of an Expression that wraps a string.
DefaultTextEdit	The default implementation of a TextEdit, which contains the location of the change within the JPQL query (offset) and the old and new values.
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.
DeleteClauseStateObject	This is the DELETE clause of the DELETE statement.
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.
DeleteStatementStateObject	Bulk delete operation apply to entities of a single entity class (together with its subclasses, if any).
DerivedCollectionMemberDeclarationBNF	The query BNF for a derived collection member declaration expression.
DerivedDeclaration	This DerivedDeclaration represents an identification variable declaration that was declared in the FROM clause of a SELECT subquery.
DerivedPathIdentificationVariableDeclarationStateObject
DerivedPathVariableDeclarationStateObject	BNF: subselect_identification_variable_declaration ::= derived_path_expression [AS] identification_variable {join}*
DivisionExpression	One of the four binary operators.
DivisionExpressionStateObject	TODO: BNF: arithmetic_expression ::= arithmetic_expression / arithmetic_term
EclipseLinkActualJPQLQueryFormatter	This IJPQLQueryFormatter is used to generate a string representation of a StateObject based on how it was parsed, which means this formatter can only be used when the StateObject was created by parsing a JPQL query because it needs to retrieve parsing information from the corresponding Expression.
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.
EclipseLinkBasicRefactoringTool	This utility class provides basic refactoring support.
EclipseLinkConditionalStateObjectBuilder	The EclipseLink extension over the basic support provided by IConditionalExpressionStateObjectBuilder.
EclipseLinkContentAssistVisitor	This extension over the default content assist visitor adds the additional support EclipseLink provides.
EclipseLinkContentAssistVisitor.AcceptableTypeVisitor
EclipseLinkContentAssistVisitor.AppendableExpressionVisitor
EclipseLinkContentAssistVisitor.EndingQueryPositionBuilder
EclipseLinkContentAssistVisitor.FollowingClausesVisitor	This visitor adds support for the additional clauses provided by EclipseLink, such as the
EclipseLinkDeclarationResolver	The EclipseLink implementation of DeclarationResolver that adds support for its additional support.
EclipseLinkExpressionVisitor	The ExpressionVisitor that adds support for the additional JPQL identifiers supported by EclipseLink that is not defined in the JPA function specification.
EclipseLinkGrammarValidator	This validator adds EclipseLink extension over what the JPA functional specification had defined.
EclipseLinkGrammarValidator.InExpressionVisitor
EclipseLinkGrammarValidator.InExpressionWithNestedArrayVisitor
EclipseLinkJPQLGrammar1	This JPQL grammar provides support for parsing JPQL queries defined in JSR-220 - Enterprise JavaBeans 3.0.
EclipseLinkJPQLGrammar2_0	This JPQLGrammar provides support for parsing JPQL queries defined in JSR-337 - Java Persistence 2.0.
EclipseLinkJPQLGrammar2_1	This JPQLGrammar provides support for parsing JPQL queries defined in JSR-337 - Java Persistence 2.0 and the additional support provided by EclipseLink 2.1.
EclipseLinkJPQLGrammar2_2	This JPQLGrammar provides support for parsing JPQL queries defined in JSR-337 - Java Persistence 2.0.
EclipseLinkJPQLGrammar2_3	This JPQLGrammar provides support for parsing JPQL queries defined in JSR-337 - Java Persistence 2.0.
EclipseLinkJPQLGrammar2_4	This JPQLGrammar provides support for parsing JPQL queries defined in JSR-338 - Java Persistence 2.1 and the additional support provided by EclipseLink 2.4.
EclipseLinkJPQLGrammar2_5	This JPQLGrammar provides support for parsing JPQL queries defined in JSR-338 - Java Persistence 2.1 and the additional support provided by EclipseLink 2.5.
EclipseLinkJPQLGrammar2_6	This JPQLGrammar provides support for parsing JPQL queries defined in JSR-338 - Java Persistence 2.1 and the additional support provided by EclipseLink 2.6.
EclipseLinkJPQLQueryBuilder	An implementation of IJPQLQueryBuilder that provides support based on the release of the Java Persistence functional specification defined in JSR-337 - Java Persistence 2.0.
EclipseLinkJPQLQueryContext	This context is used to store information related to the JPQL query.
EclipseLinkJPQLQueryFormatter	The default implementation of a IJPQLQueryFormatter that adds support for formatting EclipseLink specific JPQL identifiers.
EclipseLinkJPQLQueryHelper	This helper can perform the following operations over a JPQL query: Calculates the result type of a query: AbstractJPQLQueryHelper.getResultType(); Calculates the type of an input parameter: AbstractJPQLQueryHelper.getParameterType(String). Calculates the possible choices to complete the query from a given position (used for content assist): AbstractJPQLQueryHelper.buildContentAssistProposals(int). Validates the query by introspecting it grammatically and semantically: AbstractJPQLQueryHelper.validate(), AbstractJPQLQueryHelper.validateGrammar(), AbstractJPQLQueryHelper.validateSemantic(). Refactoring support: EclipseLinkJPQLQueryHelper.buildBasicRefactoringTool() provides support for generating the delta of the refactoring operation through a collection of TextEdit objects. EclipseLinkJPQLQueryHelper.buildRefactoringTool() provides support for refactoring the JPQL query through the editable StateObject and once all refactoring operations have been executed, the IJPQLQueryFormatter will generate a new string representation of the JPQL query. This helper should be used when the JPQL query is written using the JPQL grammar defined in the Java Persistence functional specification 2.1 and it contains the additional support provided by EclipseLink.
EclipseLinkLiteralVisitor	This visitor traverses an Expression and retrieves the "literal" value.
EclipseLinkParameterTypeVisitor	This visitor calculates the type of an input parameter.
EclipseLinkRefactoringTool	This refactoring tool add support for EclipseLink specific extension over the default implementation of JPQL defined in the Java Persistence functional specification.
EclipseLinkResolverBuilder	An implementation of a ResolverBuilder that adds support for EclipseLink extension.
EclipseLinkSelectExpressionStateObjectBuilder
EclipseLinkSemanticValidator	This validator is responsible to gather the problems found in a JPQL query by validating the content to make sure it is semantically valid for EclipseLink.
EclipseLinkSemanticValidatorExtension	This extension provides additional support to semantic validation by adding support for non-JPA specific artifacts, such as database objects.
EclipseLinkSimpleSelectExpressionStateObjectBuilder
EclipseLinkStateObjectBuilder	The default implementation of BasicStateObjectBuilder, which provides support based on the JPQL grammar defined in the Java Persistence functional specification and for the additional support provided by EclipseLink.
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.
EclipseLinkVersion	An enumeration listing the various releases of EclipseLink.
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.
EmptyCollectionComparisonExpressionStateObject	This expression tests whether or not the collection designated by the collection-valued path expression is empty (i.e, has no elements).
EmptyIterable<E>	An EmptyIterable is just that.
EmptyIterator	A null instance of an Iterator.
EncapsulatedIdentificationVariableExpression	This Expression represents an identification variable that maps a Map property, either the key, the value or a Map.Entry).
EncapsulatedIdentificationVariableExpressionStateObject	This object represents an identification variable that is wrapped by a function.
EntityExpressionBNF	The query BNF for a entity expression.
EntityOrValueExpressionBNF	The query BNF for a entity or value expression.
EntityResolver	This Resolver retrieves the type for an abstract schema name (entity name).
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.
EntityTypeLiteralStateObject	This StateObject wraps the name of an entity type.
EntryExpression	An identification variable qualified by the ENTRY operator is a path expression.
EntryExpressionFactory	This EntryExpressionFactory creates a new EntryExpression when the portion of the query to parse starts with ENTRY.
EntryExpressionStateObject	This object represents an identification variable that maps the Map.Entry) of a Map.
EnumExpressionBNF	The query BNF for a enum expression.
EnumLiteralBNF	The query BNF for an enumeration constant expression.
EnumLiteralResolver	This Resolver retrieves the type for an enum constant.
EnumPrimaryBNF	The query BNF for an enum primary expression.
EnumTypeStateObject	This StateObject wraps the name of an Enum constant.
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.
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.
Expression	This is the root interface of the parsed tree representation of a JPQL query.
ExpressionFactory	An ExpressionFactory is responsible to parse a portion of JPQL query which starts with one of the factory's JPQL identifiers.
ExpressionRegistry	This registry contains the necessary information used by Hermes parser.
ExpressionTools	A utility class containing various methods related to the Hermes parser.
ExpressionVisitor	This interface is used to traverse the JPQL parsed tree.
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.
Filter<T>	A filter is used to determine if a value can be "accepted" or "rejected".
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.
FromClauseStateObject	The FROM clause of a query defines the domain of the query by declaring identification variables.
FromSubqueryResolver	This Resolver wraps a subquery that is used as the "root" object in a query's declaration.
FromSubqueryResolver.VirtualMapping	This virtual IMapping wraps one of the select items.
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.
FunctionExpressionFactory.ParameterCount	The number of parameters a FunctionExpression can have.
FunctionExpressionStateObject
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.
GenericSemanticValidatorHelper	An implementation of SemanticValidatorHelper that uses JPQLQueryContext to return the required information and Hermes SPI.
GenericSemanticValidatorHelper.IdentificationVariableVisitor
GenericTypeHelper	This generic implementation of ITypeHelper wraps ITypeHelper and delegates the calls to it.
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.
GroupByClauseStateObject	The GROUP BY construct enables the aggregation of values according to the properties of an entity class.
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.
HavingClauseStateObject	The HAVING construct enables conditions to be specified that further restrict the query result as restrictions upon the groups.
HierarchicalQueryClause	If a table contains hierarchical data, then rows can be selected in a hierarchical order using the hierarchical query clause.
HierarchicalQueryClauseBNF
HierarchicalQueryClauseFactory	This HierarchicalQueryClauseFactory creates a new HierarchicalQueryClause when the portion of the query to parse starts with either VERSIONS or AS OF.
IAbstractConditionalExpressionStateObjectBuilder<T extends IScalarExpressionStateObjectBuilder<T>>
IBuilder<T extends StateObject,S extends StateObject>	This builder is used by BasicStateObjectBuilder, which allows subclasses to easily change any internal builders used for properly creating the state model representation of a JPQL query.
ICaseExpressionStateObjectBuilder	This builder is responsible to create a CASE expression.
IConditionalExpressionStateObjectBuilder	This builder can be used to easily create a conditional expression without having to create each object manually.
IConstructor	The external representation of a Java class constructor.
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.
IdentificationVariableDeclarationStateObject	An identification variable is a valid identifier declared in the FROM clause of a query.
IdentificationVariableFactory	This IdentificationVariableFactory creates a new IdentificationVariable.
IdentificationVariableResolver	This Resolver is responsible to resolve the type of an identification variable.
IdentificationVariableStateObject	This state object represents a single identification variable, which is identifying TODO.
IdentifierRole	A role describes the purpose of the JPQL identifier.
IEclipseLinkConditionalStateObjectBuilder	The EclipseLink extension over the basic support provided by IEclipseLinkConditionalStateObjectBuilder.
IEclipseLinkMappingType	This enumeration lists the mapping types defined in the Java Persistence functional specification and those that are provided by EclipseLink.
IEclipseLinkSelectExpressionStateObjectBuilder
IEclipseLinkSimpleSelectExpressionStateObjectBuilder
IEmbeddable	The external representation of the managed type that is annotated with @jakarta.persistence.Embeddable.
IEntity	The external representation of the managed type that is annotated with @jakarta.persistence.Entity.
IJPQLQueryBuilder	This builder is responsible to create an editable StateObject representation of a JPQL query.
IJPQLQueryFormatter	A IJPQLQueryFormatter helps to write a string representation of a StateObject.
IJPQLQueryFormatter.IdentifierStyle	This enumeration determines how the JPQL identifiers are formatted when written out.
IListChangeEvent<T>	This is used in conjunction with IListChangeListener.
IListChangeEvent.EventType	This enumeration lists the possible modification a list can have.
IListChangeListener<T>	A IListChangeListener can be registered with a StateObject in order to be notified when a list changes (items are added or removed from it or some items have been moved inside of that list).
IManagedType	The external representation of a managed type, which is a JPA persistent object.
IManagedTypeProvider	The external representation of the provider of managed types, which provide access to the JPA domain model.
IManagedTypeVisitor	The interface is used to visit a IManagedType.
IMappedSuperclass	The external representation of the managed type that is annotated with @jakarta.persistence.MappedSuperclass.
IMapping	The external representation of a mapping, which represents a single persistence property of a managed type.
IMappingBuilder<T>	A mapping builder is used to create the appropriate implementation of a IMapping.
IMappingType	This enumeration lists the mapping types defined in the Java Persistence functional specification.
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.
IndexExpressionStateObject	The INDEX function returns an integer value corresponding to the position of its argument in an ordered list.
INewValueStateObjectBuilder
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.
InExpressionStateObject	The state field path expression must have a string, numeric, or enum value.
InputParameter	Either positional or named parameters may be used.
InputParameterBNF	The query BNF for a input parameter.
InputParameterStateObject	Either positional or named parameters may be used.
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.
InternalConnectByClauseBNF
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.
IPropertyChangeEvent<T>	This is used in conjunction with IPropertyChangeListener.
IPropertyChangeListener<T>	A IPropertyChangeListener can be registered with a StateObject in order to be notified when the value of a property changes.
IQuery	The external representation of a JPQL query.
IScalarExpressionStateObjectBuilder<T extends IScalarExpressionStateObjectBuilder<T>>	This builder can be used to easily create a scalar expression without having to create each object manually.
ISelectExpressionStateObjectBuilder	This builder can be used to easily create a select expression without having to create each object manually.
IsExpressionFactory	This IsExpressionFactory creates a new expression when the portion of the query to parse starts with IS.
ISimpleSelectExpressionStateObjectBuilder	This builder can be used to easily create a select expression defined for a subquery without having to create each object manually.
IType	The external representation of a Java type.
ITypeDeclaration	The external representation of a type declaration, which is used to give more information about the type, i.e.
ITypeHelper
ITypeRepository	The external representation of the repository of Java types, which gives access to the application's classes.
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
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.
JoinStateObject	A JOIN enables the fetching of an association as a side effect of the execution of a query.
JPAVersion	An enumeration listing the various releases of the Java Persistence specification.
JPQLExpression	A JPQLExpression is the root of the parsed tree representation of a JPQL query.
JPQLGrammar	A JPQL grammar defines how a JPQL query can be parsed.
JPQLGrammar1_0	This JPQLGrammar provides support for parsing JPQL queries defined in JSR-220 - Enterprise JavaBeans 3.0.
JPQLGrammar2_0	This JPQLGrammar provides support for parsing JPQL queries defined in JSR-337 - Java Persistence 2.0.
JPQLGrammar2_1	This JPQLGrammar provides support for parsing JPQL queries defined in JSR-338 - Java Persistence 2.1.
JPQLQueryBNF	This defines a single Backus-Naur Form (BNF) of the JPQL grammar.
JPQLQueryBuilder1_0	An implementation of IJPQLQueryBuilder that provides support based on the Java Persistence functional specification defined in JSR-220 - Enterprise JavaBeans 3.0.
JPQLQueryBuilder2_0	An implementation of IJPQLQueryBuilder that provides support based on the Java Persistence functional specification defined in JSR-337 - Java Persistence 2.0.
JPQLQueryBuilder2_1	An implementation of IJPQLQueryBuilder that provides support based on the Java Persistence functional specification defined in JSR-338 - Java Persistence 2.1.
JPQLQueryBuilderWrapper	This builder wraps another builder and simply delegates the calls to it.
JPQLQueryContext	This context is used to store information related to the JPQL query.
JPQLQueryContext.QueryExpressionVisitor	This visitor is responsible to retrieve the Expression that is the beginning of a query.
JPQLQueryDeclaration	A JPQLQueryDeclaration represents either an identification variable declaration or a collection member declaration.
JPQLQueryDeclaration.Type	This enum type defines the various types of declarations supported by both the JPA functional specification and EclipseLink.
JPQLQueryProblem	A problem describes an issue found in a JPQL query because it is either grammatically or semantically incorrect.
JPQLQueryProblemMessages	The list of messages used by JPQLQueryProblems when validating a JPQL query.
JPQLQueryProblemResourceBundle	The resource bundle containing the problems encountered in a JPQL query.
JPQLQueryStateObject	This is the root of the StateObject hierarchy that represents a JPQL query.
JPQLStatementBNF	The query BNF for the JPQL expression.
KeyExpression	An identification variable qualified by the KEY operator is a path expression.
KeyExpressionFactory	This KeyExpressionFactory creates a new KeyExpression when the portion of the query to parse starts with KEY.
KeyExpressionStateObject	This object represents an identification variable that maps the keys of a Map.
KeyResolver	This Resolver is responsible to return the map key, which means that for identification variables referring to an instance of an association or collection represented as a Map, the identification variable is of the abstract schema type of the map key.
KeywordExpression	The expression representing some keywords: TRUE, FALSE or NULL.
KeywordExpressionFactory	This KeywordExpressionFactory creates a new KeywordExpression when the portion of the JPQL query to parse is FALSE, TRUE or NULL.
KeywordExpressionStateObject	The expression representing some keywords: TRUE, FALSE 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.
LengthExpressionStateObject	The LENGTH function returns the length of the string in characters as an integer.
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.
LikeExpressionStateObject	The LIKE condition is used to specify a search for a pattern.
ListChangeEvent<T>	The default implementation of IListChangeListener where the generics is the type of the items.
ListHolderStateObject<T>	A ListHolderStateObject is a StateObject having a list of children and this gives access to some operation over the list.
ListIterable<T>	A ListIterable simply forces the returned object to be an instance of ListIterator.
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.
LiteralType	Some Expression can have a "literal", this enumeration is used to visit an Expression and to retrieve the right value.
LiteralVisitor	This visitor traverses an Expression and retrieves the "literal" value.
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.
LocateExpressionStateObject	The LOCATE function returns the position of a given string within a string, starting the search at a specified position.
LogicalExpression	This expression represents a logical expression, which means the first and second expressions are aggregated with either AND or OR.
LogicalExpressionStateObject	This expression represents a logical expression, which means the first and second expressions are aggregated with either the AND or the OR operator.
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.
LowerExpressionStateObject	The LOWER function converts a string to lower case and it returns a string.
MaxFunction	One of the aggregate functions.
MaxFunctionFactory	This MaxFunctionFactory creates a new MaxFunction when the portion of the query to parse starts with MAX.
MaxFunctionStateObject	One of the aggregate functions.
MinFunction	One of the aggregate functions.
MinFunctionFactory	This MinFunctionFactory creates a new MinFunction when the portion of the query to parse starts with MIN.
MinFunctionStateObject	One of the aggregate functions.
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.
ModExpressionStateObject	The modulo operation finds the remainder of division of one number by another.
MultiplicationExpression	One of the four binary operators.
MultiplicationExpressionStateObject	TODO: 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.
NotExpressionStateObject	BNF: expression ::= NOT conditional_primary
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.
NullComparisonExpressionStateObject	A null comparison tests whether or not the single-valued path expression or input parameter is a NULL value.
NullExpression	A null Expression is used instead of a true null, which allows operations to be performed without doing a null check first.
NullFilter	A null implementation of a Filter.
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.
NullIfExpressionStateObject	NULLIF returns the first expression if the two expressions are not equal.
NullResolver	A "null" implementation of a Resolver.
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.
NumericLiteralStateObject	Exact numeric literals support the use of Java integer literal syntax as well as SQL exact numeric literal syntax.
NumericResolver	This Resolver is responsible to return the numeric type for a list of Resolvers.
NumericTypeComparator	This Comparator is used to sort ITypes based on the numerical priority.
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.
ObjectExpressionStateObject	Stand-alone identification variables in the SELECT clause may optionally be qualified by the OBJECT operator.
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.
OrderByClauseStateObject	The ORDER BY clause allows the objects or values that are returned by the query to be ordered.
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.
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.
OrderByItemBNF	The query BNF for the order by item expression.
OrderByItemFactory	This OrderByItemFactory creates a new OrderByItem.
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.
OrderSiblingsByClause	In a hierarchical query, if the rows of siblings of the same parent need to be ordered, then the ORDER SIBLINGS BY clause should be used.
OrderSiblingsByClauseBNF	The query BNF for the order siblings by clause.
OrderSiblingsByClauseFactory	This OrderSiblingsByClauseFactory creates a new OrderSiblingsByClause when the portion of the query to parse starts with ORDER SIBLINGS BY.
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.
OrExpressionStateObject	The OR logical operator chains multiple criteria together.
ParameterTypeVisitor	This visitor calculates the type of an input parameter.
PatternValueBNF	The query BNF for a pattern value.
Problem	A problem describes an issue found in a JPQL query because it is either grammatically or semantically incorrect.
PropertyChangeEvent<T>	The default implementation of IPropertyChangeEvent where the generics is the type of the old and new values.
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.
RangeDeclaration	This RangeDeclaration represents an identification variable declaration that was declared in the FROM clause of a SELECT top-level query or subquery.
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.
RangeVariableDeclarationStateObject	Range variable declarations allow the developer to designate a "root" for objects which may not be reachable by navigation.
RefactoringDelta	A refactoring delta contains an ordered collection of TextEdit.
RefactoringTool	The abstract implementation providing refactoring support for JPQL queries.
RefactoringTool.ClassNameRenamer	This visitor renames a fully qualified class name.
RefactoringTool.EntityNameRenamer	This visitor renames an entity name.
RefactoringTool.EnumConstantRenamer	This visitor renames an enum constant.
RefactoringTool.FieldNameRenamer	This visitor renames any segment of a path expression.
RefactoringTool.ResultVariableNameRenamer	This visitor renames all the result variables found in the JPQL query.
RefactoringTool.StateObjectUpdater<T extends StateObject>	This interface is used to transparently push the new value into the StateObject.
RefactoringTool.VariableNameRenamer	This visitor renames all the identification variables found in the JPQL query.
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.
Resolver	A Resolver is responsible to resolve a property by retrieving either the managed type, the mapping, the type and the type declaration depending on the type of resolver.
ResolverBuilder	This visitor creates a Resolver that gives information about the visited Expression.
ResolverBuilder.CollectionExpressionVisitor	This visitor is used to check if the expression visited is a CollectionExpression.
ResultQuery	This is used to retrieve the new JPQL query when a content assist item needs to be insert at a certain position.
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.
ResultVariableStateObject	A result variable may be used to name a select item in the query result.
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.
SelectClauseStateObject	The SELECT statement queries data from entities, which determines the type of the objects or values to be selected.
SelectExpressionBNF	The query BNF for a select expression.
SelectStatement	A SELECT query is an operation that retrieves data from one or more tables or views.
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.
SelectStatementStateObject	This state object represents a select statement, which has at least a SELECT clause and a FROM clause.
SemanticValidatorHelper	This helper is used by AbstractSemanticValidator in order to retrieve JPA information.
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.
SimpleFromClauseStateObject	The FROM clause of a sub-query defines the domain of the sub-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.
SimpleSelectClauseStateObject	The SELECT statement queries data from entities.
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.
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.
SingleElementListIterable<E>	A SingleElementListIterable returns a ListIterator that holds a single element and returns it with the first call to ListIterator.next(), at which point it will return false to any subsequent call to ListIterator.hasNext().
SingleElementListIterator<E>	A SingleElementListIterator holds a single element and returns it with the first call to SingleElementListIterator.next(), at which point it will return false to any subsequent call to SingleElementListIterator.hasNext().
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.
SizeExpressionStateObject	The SIZE function returns an integer value, the number of elements of the collection.
SnapshotCloneIterable<E>	A SnapshotCloneIterable returns an iterator on a "snapshot" of a collection, allowing for concurrent access to the original collection.
SnapshotCloneIterable.LocalCloneIterator<E>	provide access to "internal" constructor
SnapshotCloneListIterable<E>	A SnapshotCloneListIterable returns a list iterator on a "snapshot" of a list, allowing for concurrent access to the original list.
SnapshotCloneListIterable.LocalCloneListIterator<E>	provide access to "internal" constructor
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.
SqrtExpressionStateObject	The SQRT function takes a numeric argument and returns a Double.
StartWithClause	A START WITH clause is optional and specifies the root row(s) of the hierarchy.
StartWithClauseBNF	The query BNF for the START WITH clause.
StartWithClauseFactory	This StartWithClauseFactory creates a new StartWithClause when the portion of the query to parse starts with START WITH.
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.
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
StateFieldResolver	This Resolver is responsible to resolve the type of a state field, which is the leaf of the state field path expression.
StateObject	A StateObject is an editable representation of a JPQL query.
StateObjectProblem
StateObjectProblemConstants
StateObjectVisitor	The visitor is used to traverse the StateObject hierarchy that represents a JPQL query.
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.
StringLiteralStateObject	A string literal is enclosed in single quotes.
StringPrimaryBNF	The query BNF for a string primary expression.
SubExpression	This expression wraps a sub-expression within parenthesis.
SubExpressionStateObject	This expression wraps a sub-expression within parenthesis.
SubqueryBNF	The query BNF for a subquery expression.
SubqueryDeclaration	This Declaration uses a subquery as the "root" object.
SubqueryEntityResolver	This Resolver retrieves the type for an abstract schema name (entity name) if it can be resolved otherwise a derived path will be assumed.
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.
SubstringExpressionStateObject	The second and third arguments of the SUBSTRING function denote the starting position and length of the substring to be returned.
SubtractionExpression	One of the four binary operators.
SubtractionExpressionStateObject	TODO: 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.
SumFunctionResolver	This Resolver is responsible to calculate the type based on the type of the state field.
SumFunctionStateObject	One of the aggregate functions.
TableDeclaration	This Declaration uses a database table as the "root" object.
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.
TextEdit	A TextEdit contains the information of a change that can be made to the JPQL query after performing a refactoring operation.
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.
TreatExpressionStateObject	Returns an expression that allows to treat its base as if it were a subclass of the class returned by the base.
TreatResolver	This Resolver resolves a path and casts it as another entity type.
TrimExpression	The TRIM function trims the specified character from a string.
TrimExpression.Specification	The possible ways to trim the string.
TrimExpressionFactory	This TrimExpressionFactory creates a new TrimExpression when the portion of the query to parse starts with TRIM.
TrimExpressionStateObject	The TRIM function trims the specified character from a string.
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.
TypeExpressionStateObject	An entity type expression can be used to restrict query polymorphism.
TypeHelper	This helper contains methods related to IType and can perform equivalency checks.
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.
UnknownDeclaration	This Declaration represents an unknown (invalid/incomplete) declaration.
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.
UnknownExpressionStateObject	This StateObject holds onto an unknown portion of a JPQL query that could not be parsed.
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.
UpdateClauseStateObject	This is the UPDATE clause of the UPDATE statement.
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.
UpdateItemStateObject	The new_value specified for an update operation must be compatible in type with the field to which it is assigned.
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.
UpdateStatementStateObject	The UPDATE clause of a query consists of a conditional expression used to select objects or values that satisfy the expression.
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.
UpperExpressionStateObject	The UPPER function converts a string to upper case and it returns a string.
ValueExpression	An identification variable qualified by the VALUE operator is a path expression.
ValueExpressionFactory	This ValueExpressionFactory creates a new ValueExpression when the portion of the query to parse starts with VALUE.
ValueExpressionStateObject	This object represents an identification variable that maps the values of a Map.
ValueResolver	This Resolver is responsible to return the map value, which means that for identification variables referring to an instance of an association or collection represented as a Map, the identification variable is of the abstract schema type of the map value.
VariableDeclarationStateObject	This defines a variable declaration, which has a "root" object and an identification variable.
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.
WhenClauseStateObject	A WHEN predicate is used to calculate a condition and when it's true, its THEN will be executed.
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.
WhereClauseStateObject	The WHERE clause of a query consists of a conditional expression used to select objects or values that satisfy the expression.
WordParser	This "parser/scanner" holds onto the string version of the JPQL query that is parsed into a parsed tree.
WordParser.WordType	This enumeration determines the type of word that was scanned.
XmlEscapeCharacterConverter	This converter handles references when dealing with text or markup in an XML document.