Module org.eclipse.persistence.jpa.jpql
Package org.eclipse.persistence.jpa.jpql.tools.model.query

Class BetweenExpressionStateObject

java.lang.Object
org.eclipse.persistence.jpa.jpql.tools.model.query.AbstractStateObject
org.eclipse.persistence.jpa.jpql.tools.model.query.BetweenExpressionStateObject
All Implemented Interfaces:
StateObject
public class BetweenExpressionStateObject extends AbstractStateObject
Used in conditional expression to determine whether the result of an expression falls within an inclusive range of values. Numeric, string and date expression can be evaluated in this way.
BNF: between_expression ::= arithmetic_expression [NOT] BETWEEN arithmetic_expression AND arithmetic_expression |
string_expression [NOT] BETWEEN string_expression AND string_expression |
datetime_expression [NOT] BETWEEN datetime_expression AND datetime_expression
Since:
2.4
Version:
2.4
See Also:

  • Field Details

    • LOWER_STATE_OBJECT_PROPERTY

      public static final String LOWER_STATE_OBJECT_PROPERTY
      Notifies the StateObject representing the lower bound expression has changed.
      See Also:

    • NOT_PROPERTY

      public static final String NOT_PROPERTY
      Notifies the visibility of the NOT identifier has changed.
      See Also:

    • STATE_OBJECT_PROPERTY

      public static final String STATE_OBJECT_PROPERTY
      Notifies the state object property has changed.
      See Also:

    • UPPER_STATE_OBJECT_PROPERTY

      public static final String UPPER_STATE_OBJECT_PROPERTY
      Notifies the StateObject representing the upper bound expression has changed.
      See Also:

  • Constructor Details

    • BetweenExpressionStateObject

      public BetweenExpressionStateObject(StateObject parent)
      Creates a new BetweenExpressionStateObject.
      Parameters:
      parent - The parent of this state object, which cannot be null
      Throws:
      NullPointerException - The given parent cannot be null

    • BetweenExpressionStateObject

      public BetweenExpressionStateObject(StateObject parent, StateObject stateObject, boolean not, StateObject lowerBound, StateObject upperBound)
      Creates a new BetweenExpressionStateObject.
      Parameters:
      parent - The parent of this state object, which cannot be null
      stateObject - The StateObject representing the expression to compare its result to the lower and upper bounds
      not - Determines whether the NOT identifier is part of the expression or not
      lowerBound - The StateObject representing the lower bound expression
      upperBound - The StateObject representing the upper bound expression
      Throws:
      NullPointerException - The given parent cannot be null

    • BetweenExpressionStateObject

      public BetweenExpressionStateObject(StateObject parent, StateObject stateObject, StateObject lowerBound, StateObject upperBound)
      Creates a new BetweenExpressionStateObject.
      Parameters:
      parent - The parent of this state object, which cannot be null
      stateObject - The StateObject representing the expression to compare its result to the lower and upper bounds
      lowerBound - The StateObject representing the lower bound expression
      upperBound - The StateObject representing the upper bound expression
      Throws:
      NullPointerException - The given parent cannot be null

    • BetweenExpressionStateObject

      public BetweenExpressionStateObject(StateObject parent, String jpqlFragment, boolean not, String lowerBoundJpqlFragment, String upperBoundJpqlFragment)
      Creates a new BetweenExpressionStateObject.
      Parameters:
      parent - The parent of this state object, which cannot be null
      jpqlFragment - The JPQL fragment representing the expression to compare its result to the lower and upper bounds, the fragment will be parsed and converted into a StateObject
      not - Determines whether the NOT identifier is part of the expression or not
      lowerBoundJpqlFragment - The JPQL fragment representing the lower bound of the range, the fragment will be parsed and converted into a StateObject
      upperBoundJpqlFragment - The JPQL fragment representing the upper bound of the range, the fragment will be parsed and converted into a StateObject
      Throws:
      NullPointerException - The given parent cannot be null

    • BetweenExpressionStateObject

      public BetweenExpressionStateObject(StateObject parent, String jpqlFragment, String lowerBoundJpqlFragment, String upperBoundJpqlFragment)
      Creates a new BetweenExpressionStateObject.
      Parameters:
      parent - The parent of this state object, which cannot be null
      jpqlFragment - The JPQL fragment representing the expression to compare its result to the lower and upper bounds, the fragment will be parsed and converted into a StateObject
      lowerBoundJpqlFragment - The JPQL fragment representing the lowe bound of the range, the fragment will be parsed and converted into a StateObject
      upperBoundJpqlFragment - The JPQL fragment representing the upper bound of the range, the fragment will be parsed and converted into a StateObject
      Throws:
      NullPointerException - The given parent cannot be null

  • Method Details

    • accept

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

    • addChildren

      protected void addChildren(List<StateObject> children)
      Description copied from class: AbstractStateObject
      Adds the children of this StateObject to the given list.
      Overrides:
      addChildren in class AbstractStateObject
      Parameters:
      children - The list used to store the children

    • addNot

      public BetweenExpressionStateObject addNot()
      Makes sure the NOT identifier is specified.
      Returns:
      This object

    • getExpression

      public BetweenExpression getExpression()
      Description copied from interface: StateObject
      Returns the actual parsed object if this StateObject representation of the JPQL query was created by parsing an existing JPQL query.
      Specified by:
      getExpression in interface StateObject
      Overrides:
      getExpression in class AbstractStateObject
      Returns:
      The parsed object when a JPQL query is parsed and converted into a StateObject or null when the JPQL query is manually created (i.e. not from a string)

    • getLowerBound

      public StateObject getLowerBound()
      Returns the StateObject representing the lower bound of the range.
      Returns:
      The expression representing the lower bound

    • getStateObject

      public StateObject getStateObject()
      Returns the StateObject representing the expression to determine if its result falls within the lower and upper bounds.
      Returns:
      The expression to check if its result is in the range of the lower and upper bounds

    • getUpperBound

      public StateObject getUpperBound()
      Returns the StateObject representing the upper bound of the range.
      Returns:
      The expression representing the upper bound

    • hasLowerBound

      public boolean hasLowerBound()
      Determines whether the StateObject representing the lower bound is defined or not.
      Returns:
      true if the StateObject representing the expression to check if its result falls into a range has been defined; false otherwise

    • hasNot

      public boolean hasNot()
      Determines whether the NOT identifier is used or not.
      Returns:
      true if the NOT identifier is part of the expression; false otherwise

    • hasStateObject

      public boolean hasStateObject()
      Determines whether the StateObject representing the expression to determine if its result falls within the lower and upper bounds has been defined or not.
      Returns:
      true if the StateObject representing the lower bound expression has been defined; false otherwise

    • hasUpperBound

      public boolean hasUpperBound()
      Determines whether the StateObject representing the upper bound is defined or not.
      Returns:
      true if the StateObject representing the upper bound expression has been defined; false otherwise

    • isEquivalent

      public boolean isEquivalent(StateObject stateObject)
      Description copied from interface: StateObject
      Determines whether the given StateObject is equivalent to this one, i.e. the information of both StateObject is the same.
      Specified by:
      isEquivalent in interface StateObject
      Overrides:
      isEquivalent in class AbstractStateObject
      Parameters:
      stateObject - The StateObject to compare its content to this one
      Returns:
      true if both object are equivalent; false otherwise

    • parse

      public void parse(String jpqlFragment)
      Parses the given JPQL fragment, which will represent the expression to compare its result to the lower and upper bounds.
      Parameters:
      jpqlFragment - The JPQL fragment representing the expression to compare its result to the lower and upper bounds, the fragment will be parsed and converted into a StateObject

    • parseLowerBound

      public void parseLowerBound(String jpqlFragment)
      Parses the given JPQL fragment, which will represent the lower bound of the range.
      Parameters:
      jpqlFragment - The JPQL fragment representing the lower bound of the range, the fragment will be parsed and converted into a StateObject

    • parseUpperBound

      public void parseUpperBound(String jpqlFragment)
      Parses the given JPQL fragment, which will represent the upper bound of the range.
      Parameters:
      jpqlFragment - The JPQL fragment representing the upper bound of the range, the fragment will be parsed and converted into a StateObject

    • removeNot

      public void removeNot()
      Makes sure the NOT identifier is not specified.

    • setExpression

      public void setExpression(BetweenExpression expression)
      Keeps a reference of the parsed object object, which should only be done when this object is instantiated during the conversion of a parsed JPQL query into StateObjects.
      Parameters:
      expression - The parsed object representing a BETWEEN expression

    • setLowerBound

      public void setLowerBound(StateObject lowerBound)
      Sets the StateObject representing the lower bound of the range.
      Parameters:
      lowerBound - The StateObject representing the lower bound expression

    • setNot

      public void setNot(boolean not)
      Sets whether the NOT identifier should be part of the expression or not.
      Parameters:
      not - true if the NOT identifier should be part of the expression; false otherwise

    • setStateObject

      public void setStateObject(StateObject stateObject)
      Sets the StateObject representing the expression to determine if its result falls within the lower and upper bounds.
      Parameters:
      stateObject - The expression to check if its result is in the range of the lower and upper bounds

    • setUpperBound

      public void setUpperBound(StateObject upperBound)
      Sets the StateObject representing the upper bound of the range.
      Parameters:
      upperBound - The StateObject representing the upper bound expression

    • toggleNot

      public void toggleNot()
      Changes the visibility state of the NOT identifier.

    • toTextInternal

      protected void toTextInternal(Appendable writer) throws IOException
      Description copied from class: AbstractStateObject
      Prints out a string representation of this StateObject, which should not be used to define a true string representation of a JPQL query but should be used for debugging purposes.
      Specified by:
      toTextInternal in class AbstractStateObject
      Parameters:
      writer - The writer used to print out the string representation
      Throws:
      IOException - This should never happens, it is only required because Appendable is used instead of any concrete class