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

Class CollectionMemberDeclaration

java.lang.Object
org.eclipse.persistence.jpa.jpql.parser.AbstractExpression
org.eclipse.persistence.jpa.jpql.parser.CollectionMemberDeclaration
All Implemented Interfaces:
Expression
public final class CollectionMemberDeclaration extends AbstractExpression
An identification variable declared by a collection member declaration ranges over values of a collection obtained by navigation using a path expression. Such a path expression represents a navigation involving the association-fields of an entity abstract schema type. Because a path expression can be based on another path expression, the navigation can use the association-fields of related entities. An identification variable of a collection member declaration is declared using a special operator, the reserved identifier IN. The argument to the IN operator is a collection-valued path expression. The path expression evaluates to a collection type specified as a result of navigation to a collection-valued association-field of an entity abstract schema type.
BNF: collection_member_declaration ::= IN(collection_valued_path_expression) [AS] identification_variable

or
BNF: derived_collection_member_declaration ::= IN superquery_identification_variable.{single_valued_object_field.}*collection_valued_field

Example: SELECT t FROM Player p, IN (p.teams) AS t

Version:
2.5
Author:
Pascal Filion

  • Constructor Details

    • CollectionMemberDeclaration

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

  • Method Details

    • accept

      public void accept(ExpressionVisitor visitor)
      Description copied from interface: Expression
      Visits this Expression by the given visitor.
      Parameters:
      visitor - The ExpressionVisitor to visit this object

    • 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

    • 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

    • getActualAsIdentifier

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

    • getActualInIdentifier

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

    • getCollectionValuedPathExpression

      public Expression getCollectionValuedPathExpression()
      Returns the Expression representing the collection member, which is declared by an identification variable.
      Returns:
      The expression representing the collection-valued path expression

    • getIdentificationVariable

      public Expression getIdentificationVariable()
      Returns the Expression representing the identification variable, which maps the collection-valued path expression.
      Returns:
      The expression representing the identification variable

    • getQueryBNF

      public JPQLQueryBNF getQueryBNF()
      Description copied from interface: Expression
      Returns the BNF of this Expression.
      Returns:
      The JPQLQueryBNF, which represents the grammar of this Expression

    • hasAs

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

    • hasCollectionValuedPathExpression

      public boolean hasCollectionValuedPathExpression()
      Determines whether the collection-valued path expression was parsed.
      Returns:
      true if the query has the collection-valued path expression; false otherwise

    • hasIdentificationVariable

      public boolean hasIdentificationVariable()
      Determines whether the identification variable was parsed.
      Returns:
      true if the query has the identification variable; false otherwise

    • hasLeftParenthesis

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

    • hasSpaceAfterAs

      public boolean hasSpaceAfterAs()
      Determines whether a whitespace was found after AS.
      Returns:
      true if there was a whitespace after AS; false otherwise

    • hasSpaceAfterIn

      public boolean hasSpaceAfterIn()
      Determines whether a whitespace was found after IN.
      Returns:
      true if there was a whitespace after IN; false otherwise

    • hasSpaceAfterRightParenthesis

      public boolean hasSpaceAfterRightParenthesis()
      Determines whether a whitespace was found after the close parenthesis.
      Returns:
      true if there was a whitespace after the right parenthesis; false otherwise

    • isDerived

      public boolean isDerived()
      Determines whether this collection member declaration is used as a derived collection-valued path expression.
      Returns:
      true if this collection member declaration is used as this form: "IN collection_valued_path_expression" in a subquery; false if it's used as this form: IN(collection_valued_path_expression) [AS] identification_variable" in a top-level or subquery queries

    • isParsingComplete

      protected boolean isParsingComplete(WordParser wordParser, String word, Expression expression)
      Description copied from class: AbstractExpression
      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)
      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

    • 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

    • toParsedTextUntilAs

      public String toParsedTextUntilAs()
      Creates a string representation of this expression up and excluding the AS identifier.
      Returns:
      The string representation of a section of this expression