All Implemented Interfaces:
Expression

public final class TreatExpression extends AbstractEncapsulatedExpression
Returns an expression that allows to treat its base as if it were a subclass of the class returned by the base.

New to EclipseLink 2.1.

BNF: join_treat ::= TREAT(collection_valued_path_expression AS entity_type_literal)

Example: SELECT e FROM Employee e JOIN TREAT(e.projects AS LargeProject) lp WHERE lp.budget = value

Since:
2.3
Version:
2.5.1
  • Constructor Details

    • TreatExpression

      public TreatExpression(AbstractExpression parent)
      Creates a new TreatExpression.
      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
    • addOrderedEncapsulatedExpressionTo

      protected void addOrderedEncapsulatedExpressionTo(List<Expression> children)
      Description copied from class: AbstractEncapsulatedExpression
      Adds the Expressions representing the encapsulated Expression.
      Specified by:
      addOrderedEncapsulatedExpressionTo in class AbstractEncapsulatedExpression
      Parameters:
      children - The list used to store the string representation of the encapsulated Expression
    • findQueryBNF

      public final 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, or an empty string if it was not parsed
    • getCollectionValuedPathExpression

      public Expression getCollectionValuedPathExpression()
      Returns the Expression that represents the collection-valued path expression.
      Returns:
      The expression that represents the collection-valued path expression
    • getEntityType

      public Expression getEntityType()
      Returns the Expression that represents the entity type that will be used to downcast the type of the elements in the collection.
      Returns:
      The expression representing the entity type
    • 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 of the query was parsed.
      Returns:
      true if the collection-valued path expression was parsed; false if nothing was parsed
    • hasEncapsulatedExpression

      public boolean hasEncapsulatedExpression()
      Description copied from class: AbstractEncapsulatedExpression
      Determines whether something was parsed after the left parenthesis.
      Specified by:
      hasEncapsulatedExpression in class AbstractEncapsulatedExpression
      Returns:
      true if something was parsed; false otherwise
    • hasEntityType

      public boolean hasEntityType()
      Determines whether the entity type was parsed.
      Returns:
      true if the entity type was parsed; false if nothing was parsed
    • hasSpaceAfterAs

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

      public boolean hasSpaceAfterCollectionValuedPathExpression()
      Determines whether a whitespace was parsed after the collection-valued path expression.
      Returns:
      true if a whitespace was parsed after the collection-valued path expression; false otherwise
    • 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 AbstractEncapsulatedExpression
      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
    • parseEncapsulatedExpression

      protected void parseEncapsulatedExpression(WordParser wordParser, int whitespaceCount, boolean tolerant)
      Description copied from class: AbstractEncapsulatedExpression
      Parses the encapsulated expression by starting at the current position, which is part of the given WordParser.
      Specified by:
      parseEncapsulatedExpression in class AbstractEncapsulatedExpression
      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 void removeEncapsulatedExpression()
      Description copied from class: AbstractEncapsulatedExpression
      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 ')'.
      Specified by:
      removeEncapsulatedExpression in class AbstractEncapsulatedExpression
    • toParsedTextEncapsulatedExpression

      protected void toParsedTextEncapsulatedExpression(StringBuilder writer, boolean actual)
      Description copied from class: AbstractEncapsulatedExpression
      Generates a string representation of the encapsulated Expression.
      Specified by:
      toParsedTextEncapsulatedExpression in class AbstractEncapsulatedExpression
      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