Class ConstructorExpression

  • All Implemented Interfaces:

    public final class ConstructorExpression
    extends AbstractExpression
    In the SELECT clause a constructor may be used in the SELECT list to return one or more Java instances. The specified class is not required to be an entity or to be mapped to the database. The constructor name must be fully qualified.
    BNF: constructor_expression ::= NEW constructor_name(constructor_item {, constructor_item}*)

    Pascal Filion
    • Constructor Detail

      • ConstructorExpression

        public ConstructorExpression​(AbstractExpression parent)
        Creates a new ConstructorExpression.
        parent - The parent of this expression
    • Method Detail

      • buildCollectionExpression

        public CollectionExpression buildCollectionExpression()
        Creates a new CollectionExpression that will wrap the single constructor item.
        The single constructor item represented by a temporary collection
      • getActualIdentifier

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

        public java.lang.String getClassName()
        Returns the fully qualified class name that will be used to retrieve the constructor.
        The fully qualified class name or an empty string if it is not defined
      • getConstructorItems

        public Expression getConstructorItems()
        Returns the constructor items aggregated into a single expression and separated by commas or a single expression.
        The constructor item or items or an invalid or "null" expression
      • hasConstructorItems

        public boolean hasConstructorItems()
        Determines whether the constructor items were parsed.
        true if the query had at least one constructor item; false otherwise
      • hasLeftParenthesis

        public boolean hasLeftParenthesis()
        Determines whether the open parenthesis was parsed or not.
        true if the open parenthesis was present in the string version of the query; false otherwise
      • hasRightParenthesis

        public boolean hasRightParenthesis()
        Determines whether the close parenthesis was parsed or not.
        true if the close parenthesis was present in the string version of the query; false otherwise
      • hasSpaceAfterNew

        public boolean hasSpaceAfterNew()
        Determines whether a whitespace was parsed after NEW.
        true if there was a whitespace after NEW; false otherwise
      • isParsingComplete

        protected boolean isParsingComplete​(WordParser wordParser,
                                            java.lang.String word,
                                            Expression expression)
        Determines whether the parsing is complete based on what is left in the given text. The text is never empty.
        isParsingComplete in class AbstractExpression
        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
        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)
        Parses the query by starting at the current position, which is part of the given WordParser.
        Specified by:
        parse in class AbstractExpression
        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
      • shouldSkipLiteral

        protected boolean shouldSkipLiteral​(AbstractExpression expression)
        When parsing an invalid or incomplete query, it is possible two literals would be parsed but in some cases, a CollectionExpression should not be created and the parsing should actually stop here. Example: BETWEEN 10 20, when parsing 20, it should not be parsed as part of the lower bound expression.
        shouldSkipLiteral in class AbstractExpression
        expression - The Expression that has just been parsed or null
      • toParsedText

        protected void toParsedText​(java.lang.StringBuilder writer,
                                    boolean actual)
        Generates a string representation of this Expression, including its children, if it has any.
        Specified by:
        toParsedText in class AbstractExpression
        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