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

Class AbstractSelectClause

java.lang.Object
org.eclipse.persistence.jpa.jpql.parser.AbstractExpression
org.eclipse.persistence.jpa.jpql.parser.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:
Author:
Pascal Filion

  • Constructor Details

    • AbstractSelectClause

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

  • Method Details

    • acceptChildren

      public void acceptChildren(ExpressionVisitor visitor)
      Description copied from interface: Expression
      Visits the children of this Expression. This method can be used to optimize traversing the children since a new list is not created every time Expression.children() is called.

      This does not traverse the Expression sub-hierarchy, use a subclass of AbstractTraverseChildrenVisitor in order to traverse the entire sub-hierarchy.

      Parameters:
      visitor - The visitor to visit the children of this object.

    • addChildrenTo

      protected void addChildrenTo(Collection<Expression> children)
      Description copied from class: AbstractExpression
      Adds the children of this AbstractExpression to the given collection.
      Overrides:
      addChildrenTo in class AbstractExpression
      Parameters:
      children - The collection used to store the children

    • addOrderedChildrenTo

      protected void addOrderedChildrenTo(List<Expression> children)
      Description copied from class: AbstractExpression
      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

    • 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

    • findQueryBNF

      public JPQLQueryBNF findQueryBNF(Expression expression)
      Description copied from interface: Expression
      Retrieves the JPQLQueryBNF that represents the fragment of this Expression that was used when parsing the given Expression.
      Specified by:
      findQueryBNF in interface Expression
      Overrides:
      findQueryBNF in class AbstractExpression
      Parameters:
      expression - The Expression that is a descendant of this one
      Returns:
      The JPQLQueryBNF that was used to parse the given expression

    • getActualDistinctIdentifier

      public final 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

    • getActualIdentifier

      public final 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 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)
      Description copied from class: AbstractExpression
      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)
      Description copied from class: AbstractExpression
      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(StringBuilder writer, boolean actual)
      Description copied from class: AbstractExpression
      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