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

Class OrderByItem

java.lang.Object
org.eclipse.persistence.jpa.jpql.parser.AbstractExpression
org.eclipse.persistence.jpa.jpql.parser.OrderByItem
All Implemented Interfaces:
Expression
public final class OrderByItem extends AbstractExpression
An orderby_item must be one of the following:
  1. A state_field_path_expression that evaluates to an orderable state field of an entity or embeddable class abstract schema type designated in the SELECT clause by one of the following:
    • A general_identification_variable
    • A single_valued_object_path_expression
  2. A state_field_path_expression that evaluates to the same state field of the same entity or embeddable abstract schema type as a state_field_path_expression in the SELECT clause
  3. A result_variable that refers to an orderable item in the SELECT clause for which the same result_variable has been specified. This may be the result of an aggregate_expression, a scalar_expression, or a state_field_path_expression in the SELECT clause.

The keyword ASC specifies that ascending ordering be used for the associated orderby_item; the keyword DESC specifies that descending ordering be used. Ascending ordering is the default.
The keyword NULLS FIRST specifies that nulls first ordering be used for the associated orderby_item; the keyword NULLS LAST specifies that nulls last ordering be used. Ascending ordering is the default.
JPA 1.0:
BNF: orderby_item ::= state_field_path_expression [ ASC | DESC ]

JPA 2.0
BNF: orderby_item ::= state_field_path_expression | result_variable [ ASC | DESC ]

EclipseLink 2.4:
BNF: orderby_item ::= state_field_path_expression | result_variable [ ASC | DESC ] [ NULLS FIRST | NULLS LAST ]
Since:
2.3
Version:
2.5

  • Constructor Details

    • OrderByItem

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

    • getActualNullOrdering

      public String getActualNullOrdering()
      Returns the actual null ordering identifier found in the string representation of the JPQL query, which has the actual case that was used.
      Returns:
      The null ordering identifier that was actually parsed, if one was present, otherwise an empty string is returned

    • getActualOrdering

      public String getActualOrdering()
      Returns the actual ordering identifier found in the string representation of the JPQL query, which has the actual case that was used.
      Returns:
      The ordering identifier that was actually parsed, if one was present, otherwise an empty string is returned

    • getExpression

      public Expression getExpression()
      Returns the Expression that represents the order by expression.
      Returns:
      The expression that was parsed representing the order by expression

    • getNullOrdering

      public OrderByItem.NullOrdering getNullOrdering()
      Returns the enum constant representing the null ordering type.
      Returns:
      The constant representing the null ordering, in the case the ordering was not parsed, then OrderByItem.NullOrdering.DEFAULT is returned

    • getOrdering

      public OrderByItem.Ordering getOrdering()
      Returns the enum constant representing the ordering type.
      Returns:
      The constant representing the ordering, in the case the ordering was not parsed, then OrderByItem.Ordering.DEFAULT is returned

    • 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

    • hasExpression

      public boolean hasExpression()
      Determines whether the order by expression was parsed.
      Returns:
      true if the order by expression was parsed; false otherwise

    • hasNulls

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

    • hasOrdering

      public boolean hasOrdering()
      Determines whether ASC or DESC was parsed.
      Returns:
      true if the ordering status was parsed; false otherwise
      Since:
      2.5

    • hasSpaceAfterExpression

      public boolean hasSpaceAfterExpression()
      Determines whether a whitespace was parsed after the order by expression.
      Returns:
      true if there was a whitespace after the order by expression; false otherwise

    • hasSpaceAfterNulls

      public boolean hasSpaceAfterNulls()
      Determines whether a whitespace was parsed after the NULLS identifier. If the composite identifier was fully parsed - NULLS FIRST or NULLS LAST - then this is always true, but if only NULLS was parsed, then this can be useful to determine if there was a space after.
      Returns:
      true if there was a whitespace after the NULLS identifier; false otherwise

    • hasSpaceAfterOrdering

      public boolean hasSpaceAfterOrdering()
      Determines whether a whitespace was parsed after the ordering.
      Returns:
      true if there was a whitespace after the ordering; false otherwise

    • isAscending

      public boolean isAscending()
      Determines whether the ordering was specified as being ascendant.
      Returns:
      true if ASC was parsed; false otherwise

    • isDefault

      public boolean isDefault()
      Determines whether the ordering was not specified.
      Returns:
      true if no ordering was parsed; false otherwise

    • isDescending

      public boolean isDescending()
      Determines whether the ordering was specified as being descendant.
      Returns:
      true if DESC was parsed; false otherwise

    • isNullsFirst

      public boolean isNullsFirst()
      Determines whether the ordering was specified as being nulls first.
      Returns:
      true if NULLS FIRST was parsed; false otherwise

    • isNullsLast

      public boolean isNullsLast()
      Determines whether the ordering was specified as being nulls first.
      Returns:
      true if NULLS LAST was parsed; 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