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

Class AbstractSelectClause

  • All Implemented Interfaces:
    Expression
    Direct Known Subclasses:
    SelectClause, SimpleSelectClause
    public abstract class AbstractSelectClause
extends AbstractExpression
    The SELECT clause denotes the query result. More than one value may be returned from the SELECT clause of a query. The SELECT clause may contain one or more of the following elements: a single range variable or identification variable that ranges over an entity abstract schema type, a single-valued path expression, an aggregate select expression, a constructor expression.

    The DISTINCT keyword is used to specify that duplicate values must be eliminated from the query result. If DISTINCT is not specified, duplicate values are not eliminated. Stand-alone identification variables in the SELECT clause may optionally be qualified by the OBJECT operator. The SELECT clause must not use the OBJECT operator to qualify path expressions.

    Version:
    2.5
    See Also:
    SelectClause, SimpleSelectClause
    Author:
    Pascal Filion
    Since:
    2.3

    • Constructor Detail

      • AbstractSelectClause

        protected AbstractSelectClause​(AbstractExpression parent)
        Creates a new SelectClause.
        Parameters:
        parent - The parent of this expression

    • Method Detail

      • buildCollectionExpression

        public CollectionExpression buildCollectionExpression()
        Creates a new CollectionExpression that will wrap the single select item.
        Returns:
        The single select item represented by a temporary collection

      • getActualDistinctIdentifier

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

      • getActualIdentifier

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

      • getSelectExpression

        public final Expression getSelectExpression()
        Returns the Expression representing the select items.
        Returns:
        The expression representing the select items

      • getSelectItemQueryBNFId

        public abstract java.lang.String getSelectItemQueryBNFId()
        Returns the unique identifier of the JPQLQueryBNF for the list of select items to parse.
        Returns:
        The ID of the query BNF for the list of select items to parse

      • hasDistinct

        public final boolean hasDistinct()
        Determines whether the identifier DISTINCT was parsed or not.
        Returns:
        true if the identifier DISTINCT was parsed; false otherwise

      • hasSelectExpression

        public final boolean hasSelectExpression()
        Determines whether the list of select items was parsed.
        Returns:
        true the list of select items was parsed; false otherwise

      • hasSpaceAfterDistinct

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

      • hasSpaceAfterSelect

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

      • 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

      • shouldSkipLiteral

        protected boolean shouldSkipLiteral​(AbstractExpression expression)
        When parsing an invalid or incomplete query, it is possible two literals would be parsed but in some cases, a CollectionExpression should not be created and the parsing should actually stop here. Example: BETWEEN 10 20, when parsing 20, it should not be parsed as part of the lower bound expression.
        Overrides:
        shouldSkipLiteral in class AbstractExpression
        Parameters:
        expression - The Expression that has just been parsed or null
        Returns:
        true

      • 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