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

Class CaseExpression

  • All Implemented Interfaces:
    Expression
    public final class CaseExpression
extends AbstractExpression
    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

    Version:
    2.5
    Author:
    Pascal Filion
    Since:
    2.3

    • Constructor Detail

      • CaseExpression

        public CaseExpression​(AbstractExpression parent)
        Creates a new CaseExpression.
        Parameters:
        parent - The parent of this expression

    • Method Detail

      • getActualCaseIdentifier

        public java.lang.String getActualCaseIdentifier()
        Returns the actual CASE identifier found in the string representation of the JPQL query, which has the actual case that was used.
        Returns:
        The CASE identifier that was actually parsed

      • getActualElseIdentifier

        public java.lang.String getActualElseIdentifier()
        Returns the actual ELSE identifier found in the string representation of the JPQL query, which has the actual case that was used.
        Returns:
        The ELSE identifier that was actually parsed, or an empty string if it was not parsed

      • getActualEndIdentifier

        public java.lang.String getActualEndIdentifier()
        Returns the actual END identifier found in the string representation of the JPQL query, which has the actual case that was used.
        Returns:
        The END identifier that was actually parsed, or an empty string if it was not parsed

      • getCaseOperand

        public Expression getCaseOperand()
        Returns the Expression that represents the CASE operand.
        Returns:
        The expression that was parsed representing the CASE operand

      • getElseExpression

        public AbstractExpression getElseExpression()
        Returns the Expression that represents the ELSE operand.
        Returns:
        The expression that was parsed representing the ELSE operand

      • getWhenClauses

        public AbstractExpression getWhenClauses()
        Returns the Expression that represents the WHEN clauses.
        Returns:
        The expression that was parsed representing the WHEN clauses

      • hasCaseOperand

        public boolean hasCaseOperand()
        Determines whether the CASE operand was parsed.
        Returns:
        true if the CASE operand was parsed; false otherwise

      • hasElse

        public boolean hasElse()
        Determines whether the identifier ELSE was parsed.
        Returns:
        true if the identifier ELSE was parsed; false otherwise

      • hasElseExpression

        public boolean hasElseExpression()
        Determines whether the ELSE expression was parsed.
        Returns:
        true if the ELSE expression was parsed; false otherwise

      • hasEnd

        public boolean hasEnd()
        Determines whether the identifier END was parsed.
        Returns:
        true if the identifier END was parsed; false otherwise

      • hasSpaceAfterCase

        public boolean hasSpaceAfterCase()
        Determines whether a whitespace was parsed after CASE.
        Returns:
        true if there was a whitespace after CASE; false otherwise

      • hasSpaceAfterCaseOperand

        public boolean hasSpaceAfterCaseOperand()
        Determines whether a whitespace was parsed after the case operand.
        Returns:
        true if there was a whitespace after the case operand; false otherwise

      • hasSpaceAfterElse

        public boolean hasSpaceAfterElse()
        Determines whether a whitespace was parsed after ELSE.
        Returns:
        true if there was a whitespace after ELSE; false otherwise

      • hasSpaceAfterElseExpression

        public boolean hasSpaceAfterElseExpression()
        Determines whether a whitespace was parsed after the else expression.
        Returns:
        true if there was a whitespace after the else expression; false otherwise

      • hasSpaceAfterWhenClauses

        public boolean hasSpaceAfterWhenClauses()
        Determines whether a whitespace was parsed after the WHEN clause.
        Returns:
        true if there was a whitespace after the WHEN clause; false otherwise

      • hasWhenClauses

        public boolean hasWhenClauses()
        Determines whether the WHEN clauses were parsed.
        Returns:
        true if the WHEN clauses were parsed; 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

      • toParsedText

        protected 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