Class LikeExpression

java.lang.Object
org.eclipse.persistence.jpa.jpql.parser.AbstractExpression
org.eclipse.persistence.jpa.jpql.parser.LikeExpression
All Implemented Interfaces:
Expression

public final class LikeExpression extends AbstractExpression
The LIKE condition is used to specify a search for a pattern.

The string_expression must have a string value. The pattern_value is a string literal or a string-valued input parameter in which an underscore (_) stands for any single character, a percent (%) character stands for any sequence of characters (including the empty sequence), and all other characters stand for themselves. The optional escape_character is a single-character string literal or a character-valued input parameter (i.e., char or Character) and is used to escape the special meaning of the underscore and percent characters in pattern_value.

BNF: like_expression ::= string_expression [NOT] LIKE pattern_value [ESCAPE escape_character]

Version:
2.5
Author:
Pascal Filion
  • Constructor Details

    • LikeExpression

      public LikeExpression(AbstractExpression parent, AbstractExpression stringExpression)
      Creates a new LikeExpression.
      Parameters:
      parent - The parent of this expression
      stringExpression - The first part of this expression, which is the string 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
    • getActualEscapeIdentifier

      public String getActualEscapeIdentifier()
      Returns the actual ESCAPE found in the string representation of the JPQL query, which has the actual case that was used.
      Returns:
      The ESCAPE identifier that was actually parsed, or an empty string if it was not parsed
    • getActualLikeIdentifier

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

      public String getActualNotIdentifier()
      Returns the actual NOT found in the string representation of the JPQL query, which has the actual case that was used.
      Returns:
      The NOT identifier that was actually parsed, or an empty string if it was not parsed
    • getEscapeCharacter

      public Expression getEscapeCharacter()
      Returns the Expression that represents the escape character, which is either a single character or an input parameter.
      Returns:
      The expression that was parsed representing the escape character
    • getIdentifier

      public String getIdentifier()
      Returns the enum constant that represents the identifier.
      Returns:
      Either LIKE or NOT LIKE
    • getPatternValue

      public Expression getPatternValue()
      Returns the Expression that represents the pattern value.
      Returns:
      The expression that was parsed representing the pattern value
    • 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
    • getStringExpression

      public Expression getStringExpression()
      Returns the Expression that represents the string expression.
      Returns:
      The expression that was parsed representing the string expression
    • hasEscape

      public boolean hasEscape()
      Determines whether the identifier ESCAPE was parsed.
      Returns:
      true if the identifier ESCAPE was parsed; false otherwise
    • hasEscapeCharacter

      public boolean hasEscapeCharacter()
      Determines whether the escape character was parsed, which is either a single character or an input parameter.
      Returns:
      true if the escape character was parsed; false otherwise
    • hasNot

      public boolean hasNot()
      Determines whether the identifier NOT was parsed.
      Returns:
      true if the identifier NOT was parsed; false otherwise
    • hasPatternValue

      public boolean hasPatternValue()
      Determines whether the pattern value was parsed.
      Returns:
      true if the pattern value was parsed; false otherwise
    • hasSpaceAfterEscape

      public boolean hasSpaceAfterEscape()
      Determines whether a whitespace was parsed after ESCAPE.
      Returns:
      true if there was a whitespace after ESCAPE; false otherwise
    • hasSpaceAfterLike

      public boolean hasSpaceAfterLike()
      Determines whether a whitespace was parsed after LIKE.
      Returns:
      true if there was a whitespace after LIKE; false otherwise
    • hasSpaceAfterPatternValue

      public boolean hasSpaceAfterPatternValue()
      Determines whether a whitespace was parsed after the pattern value.
      Returns:
      true if there was a whitespace after the pattern value; false otherwise
    • hasSpaceAfterStringExpression

      public boolean hasSpaceAfterStringExpression()
      Determines whether a whitespace was parsed after the string expression.
      Returns:
      true if there was a whitespace after the string expression; false otherwise
    • hasStringExpression

      public boolean hasStringExpression()
      Determines whether the string expression was parsed.
      Returns:
      true if the string expression 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