All Implemented Interfaces:
Expression

public final class Join extends AbstractExpression
A JOIN enables the fetching of an association as a side effect of the execution of a query. A JOIN is specified over an entity and its related entities.
BNF: join ::= join_spec join_association_path_expression [AS] identification_variable

A JOIN FETCH enables the fetching of an association as a side effect of the execution of a query. A JOIN FETCH is specified over an entity and its related entities.

BNF: fetch_join ::= join_spec FETCH join_association_path_expression

EclipseLink 2.4

BNF: join_spec { abstract_schema_name | join_association_path_expression } [AS] identification_variable [join_condition]
Since:
2.3
Version:
2.5
  • Constructor Details

    • Join

      public Join(AbstractExpression parent, String identifier)
      Creates a new Join.
      Parameters:
      parent - The parent of this expression
      identifier - The full JOIN identifier
  • 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 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
    • getActualIdentifier

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

      public Expression getIdentificationVariable()
      Returns the Expression that represents the identification variable.
      Returns:
      The expression that was parsed representing the identification variable
    • getIdentifier

      public String getIdentifier()
      Returns the identifier this expression represents.
      Returns:
      Either JOIN, INNER JOIN, LEFT JOIN or LEFT OUTER JOIN. Although it's possible to have an incomplete identifier if the query is not complete
    • getJoinAssociationPath

      public Expression getJoinAssociationPath()
      Returns the Expression that represents the join association path expression.
      Returns:
      The expression that was parsed representing the join association path expression
    • getOnClause

      public Expression getOnClause()
      Returns the Expression that represents the ON clause if present.
      Returns:
      The expression that was parsed 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
    • hasFetch

      public boolean hasFetch()
      Determines whether the identifier FETCH was parsed.
      Returns:
      true if the identifier FETCH was parsed; false otherwise
    • hasIdentificationVariable

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

      public boolean hasJoinAssociationPath()
      Determines whether the join association path expression was parsed.
      Returns:
      true if the join association path expression was parsed; false otherwise
    • hasOnClause

      public boolean hasOnClause()
      Determines whether the ON clause was parsed.
      Returns:
      true if the ON clause was parsed; false otherwise
    • hasSpaceAfterAs

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

      public boolean hasSpaceAfterIdentificationVariable()
      Determines whether a whitespace was parsed before ON.
      Returns:
      true if there was a whitespace before ON; false otherwise
    • hasSpaceAfterJoin

      public boolean hasSpaceAfterJoin()
      Determines whether a whitespace was parsed after JOIN.
      Returns:
      true if there was a whitespace after JOIN; false otherwise
    • hasSpaceAfterJoinAssociation

      public boolean hasSpaceAfterJoinAssociation()
      Determines whether a whitespace was parsed after the join association path expression.
      Returns:
      true if there was a whitespace after join association path expression; false otherwise
    • isLeftJoin

      public boolean isLeftJoin()
      Returns:
      true if this Join expression is a Expression.LEFT_JOIN, Expression.LEFT_JOIN_FETCH, Expression.LEFT_OUTER_JOIN, Expression.LEFT_OUTER_JOIN_FETCH; 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 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