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

Class AbstractEncapsulatedExpression

java.lang.Object

org.eclipse.persistence.jpa.jpql.parser.AbstractExpression

org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression

All Implemented Interfaces:

Expression

Direct Known Subclasses:

AbstractDoubleEncapsulatedExpression, AbstractSingleEncapsulatedExpression, AbstractTripleEncapsulatedExpression, TreatExpression

public abstract class AbstractEncapsulatedExpression
extends AbstractExpression

This expression handles parsing the identifier followed by an expression encapsulated within parenthesis.

BNF: expression ::= <identifier>(expression)

Version:

2.5

Author:

Pascal Filion

Since:

2.3

Field Summary

Fields inherited from class org.eclipse.persistence.jpa.jpql.parser.AbstractExpression

COMMA, DOT, DOUBLE_QUOTE, LEFT_CURLY_BRACKET, LEFT_PARENTHESIS, NOT_DEFINED, RIGHT_CURLY_BRACKET, RIGHT_PARENTHESIS, SINGLE_QUOTE, SPACE, UNDERSCORE

Fields inherited from interface org.eclipse.persistence.jpa.jpql.parser.Expression

ABS, ALL, AND, ANY, AS, AS_OF, ASC, AVG, BETWEEN, BIT_LENGTH, BOTH, CASE, CAST, CHAR_LENGTH, CHARACTER_LENGTH, CLASS, COALESCE, COLUMN, CONCAT, CONNECT_BY, COUNT, CURRENT_DATE, CURRENT_TIME, CURRENT_TIMESTAMP, DELETE, DELETE_FROM, DESC, DIFFERENT, DISTINCT, DIVISION, ELSE, EMPTY, END, ENTRY, EQUAL, ESCAPE, EXCEPT, EXISTS, EXTRACT, FALSE, FETCH, FIRST, FROM, FUNC, FUNCTION, GREATER_THAN, GREATER_THAN_OR_EQUAL, GROUP_BY, HAVING, IN, INDEX, INNER, INNER_JOIN, INNER_JOIN_FETCH, INTERSECT, IS, IS_EMPTY, IS_NOT_EMPTY, IS_NOT_NULL, IS_NULL, JOIN, JOIN_FETCH, KEY, LAST, LEADING, LEFT, LEFT_JOIN, LEFT_JOIN_FETCH, LEFT_OUTER_JOIN, LEFT_OUTER_JOIN_FETCH, LENGTH, LIKE, LOCATE, LOWER, LOWER_THAN, LOWER_THAN_OR_EQUAL, MAX, MEMBER, MEMBER_OF, MIN, MINUS, MOD, MULTIPLICATION, NAMED_PARAMETER, NEW, NOT, NOT_BETWEEN, NOT_EQUAL, NOT_EXISTS, NOT_IN, NOT_LIKE, NOT_MEMBER, NOT_MEMBER_OF, NULL, NULLIF, NULLS, NULLS_FIRST, NULLS_LAST, OBJECT, OF, ON, OPERATOR, OR, ORDER_BY, ORDER_SIBLINGS_BY, OUTER, PLUS, POSITION, POSITIONAL_PARAMETER, QUOTE, REGEXP, SCN, SELECT, SET, SIZE, SOME, SQL, SQRT, START_WITH, SUBSTRING, SUM, TABLE, THEN, TIMESTAMP, TRAILING, TREAT, TRIM, TRUE, TYPE, UNION, UNKNOWN, UPDATE, UPPER, VALUE, WHEN, WHERE

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	AbstractEncapsulatedExpression(AbstractExpression parent, java.lang.String identifier)	Creates a new AbstractEncapsulatedExpression.

Method Summary

Modifier and Type	Method	Description
protected void	addOrderedChildrenTo(java.util.List<Expression> children)	Adds the children of this AbstractExpression to the given list.
protected abstract void	addOrderedEncapsulatedExpressionTo(java.util.List<Expression> children)	Adds the Expressions representing the encapsulated Expression.
protected boolean	areLogicalIdentifiersSupported()
java.lang.String	getActualIdentifier()	Returns the actual identifier found in the string representation of the JPQL query, which has the actual case that was used.
java.lang.String	getIdentifier()	Returns the JPQL identifier of this expression.
abstract boolean	hasEncapsulatedExpression()	Determines whether something was parsed after the left parenthesis.
boolean	hasLeftParenthesis()	Determines whether the open parenthesis was parsed or not.
boolean	hasRightParenthesis()	Determines whether the close parenthesis was parsed or not.
boolean	hasSpaceAfterIdentifier()	Determines whether a whitespace was parsed after the identifier rather than the left parenthesis.
protected boolean	isParsingComplete(WordParser wordParser, java.lang.String word, Expression expression)	Determines whether the parsing is complete based on what is left in the given text.
protected void	parse(WordParser wordParser, boolean tolerant)	Parses the query by starting at the current position, which is part of the given WordParser.
protected abstract void	parseEncapsulatedExpression(WordParser wordParser, int whitespaceCount, boolean tolerant)	Parses the encapsulated expression by starting at the current position, which is part of the given WordParser.
protected abstract void	removeEncapsulatedExpression()	Removes the encapsulated Expression that was parsed, it should not be part of this one.
protected boolean	shouldParseRightParenthesis(WordParser wordParser, boolean tolerant)	Determines whether the right parenthesis should be parsed or not by this expression.
protected void	toParsedText(java.lang.StringBuilder writer, boolean actual)	Generates a string representation of this Expression, including its children, if it has any.
protected abstract void	toParsedTextEncapsulatedExpression(java.lang.StringBuilder writer, boolean actual)	Generates a string representation of the encapsulated Expression.

Methods inherited from class org.eclipse.persistence.jpa.jpql.parser.AbstractExpression

acceptUnknownVisitor, acceptUnknownVisitor, addChildrenTo, buildExpressionFromFallingBack, buildNullExpression, buildStringExpression, buildStringExpression, buildUnknownExpression, calculatePosition, children, findFallBackExpressionFactory, findQueryBNF, getExpressionFactory, getExpressionRegistry, getGrammar, getIdentifierVersion, getJPAVersion, getLength, getOffset, getParent, getQueryBNF, getRoot, getText, handleAggregate, handleCollection, isAncestor, isIdentifier, isNull, isTolerant, isUnknown, isVirtual, orderedChildren, parse, parseUsingExpressionFactory, populatePosition, rebuildActualText, rebuildParsedText, setParent, setText, shouldParseWithFactoryFirst, shouldSkipLiteral, toActualText, toParsedText, toString

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.eclipse.persistence.jpa.jpql.parser.Expression

accept, acceptChildren, getQueryBNF

Constructor Detail

AbstractEncapsulatedExpression

protected AbstractEncapsulatedExpression(AbstractExpression parent,
                                         java.lang.String identifier)

Creates a new AbstractEncapsulatedExpression.

Parameters:

parent - The parent of this expression

identifier - The JPQL identifier that starts this expression

Method Detail

addOrderedChildrenTo

protected final void addOrderedChildrenTo(java.util.List<Expression> children)

Adds the children of this AbstractExpression to the given list.

Overrides:

addOrderedChildrenTo in class AbstractExpression

Parameters:

children - The list used to store the string representation of this AbstractExpression

addOrderedEncapsulatedExpressionTo

protected abstract void addOrderedEncapsulatedExpressionTo(java.util.List<Expression> children)

Adds the Expressions representing the encapsulated Expression.

Parameters:

children - The list used to store the string representation of the encapsulated Expression

areLogicalIdentifiersSupported

protected boolean areLogicalIdentifiersSupported()

getActualIdentifier

public final java.lang.String getActualIdentifier()

Returns the actual identifier found in the string representation of the JPQL query, which has the actual case that was used.

Returns:

The JPQL identifier that was actually parsed

getIdentifier

public final java.lang.String getIdentifier()

Returns the JPQL identifier of this expression.

Returns:

The JPQL identifier

hasEncapsulatedExpression

public abstract boolean hasEncapsulatedExpression()

Determines whether something was parsed after the left parenthesis.

Returns:

true if something was parsed; false otherwise

hasLeftParenthesis

public final boolean hasLeftParenthesis()

Determines whether the open parenthesis was parsed or not.

Returns:

true if the open parenthesis was present in the string version of the query; false otherwise

hasRightParenthesis

public final boolean hasRightParenthesis()

Determines whether the close parenthesis was parsed or not.

Returns:

true if the close parenthesis was present in the string version of the query; false otherwise

hasSpaceAfterIdentifier

public boolean hasSpaceAfterIdentifier()

Determines whether a whitespace was parsed after the identifier rather than the left parenthesis. This can happen in incomplete query of this form: ABS 4 + 5).

Returns:

true if a whitespace was parsed after the identifier; false otherwise

isParsingComplete

protected boolean isParsingComplete(WordParser wordParser,
                                    java.lang.String word,
                                    Expression expression)

Determines whether the parsing is complete based on what is left in the given text. The text is never empty.

Overrides:

isParsingComplete in class AbstractExpression

Parameters:

wordParser - The text to parse based on the current position of the cursor

word - The word that was retrieved from the given text, which is the first word in the text

expression - The Expression that has already been parsed

Returns:

true if the text no longer can't be parsed by the current expression; false if more can be parsed

parse

protected void parse(WordParser wordParser,
                     boolean tolerant)

Parses the query by starting at the current position, which is part of the given WordParser.

Specified by:

parse in class AbstractExpression

Parameters:

wordParser - The text to parse based on the current position of the cursor

tolerant - Determines whether the parsing system should be tolerant, meaning if it should try to parse invalid or incomplete queries

parseEncapsulatedExpression

protected abstract void parseEncapsulatedExpression(WordParser wordParser,
                                                    int whitespaceCount,
                                                    boolean tolerant)

Parses the encapsulated expression by starting at the current position, which is part of the given WordParser.

Parameters:

wordParser - The text to parse based on the current position of the cursor

whitespaceCount - The number of whitespace characters that were parsed after '('

tolerant - Determines whether the parsing system should be tolerant, meaning if it should try to parse invalid or incomplete queries

removeEncapsulatedExpression

protected abstract void removeEncapsulatedExpression()

Removes the encapsulated Expression that was parsed, it should not be part of this one. This happens when the parsed information does not have both '(' and ')'.

shouldParseRightParenthesis

protected boolean shouldParseRightParenthesis(WordParser wordParser,
                                              boolean tolerant)

Determines whether the right parenthesis should be parsed or not by this expression. There is a possible case where this expression should have optional left and right parenthesis. If there is no left parenthesis, then it would most likely mean the right parenthesis does not belong to this expression.

Parameters:

wordParser - The text to parse based on the current position of the cursor

tolerant - Determines whether the parsing system should be tolerant, meaning if it should try to parse invalid or incomplete queries

Returns:

true if the right parenthesis should be owned by this expression if it is the next character to scan; false otherwise

toParsedText

protected final void toParsedText(java.lang.StringBuilder writer,
                                  boolean actual)

Generates a string representation of this Expression, including its children, if it has any.

Specified by:

toParsedText in class AbstractExpression

Parameters:

writer - The buffer used to append this Expression's string representation

actual - Determines whether the string representation should represent what was parsed, i.e. include any "virtual" whitespace (such as ending whitespace) and the actual case of the JPQL identifiers

toParsedTextEncapsulatedExpression

protected abstract void toParsedTextEncapsulatedExpression(java.lang.StringBuilder writer,
                                                           boolean actual)

Generates a string representation of the encapsulated Expression.

Parameters:

writer - The buffer used to append the encapsulated Expression's string representation

actual - Determines whether to include any characters that are considered virtual, i.e. that was parsed when the query is incomplete and is needed for functionality like content assist