Class AggregateFunction

  • All Implemented Interfaces:
    Direct Known Subclasses:
    AvgFunction, CountFunction, MaxFunction, MinFunction, SumFunction

    public abstract class AggregateFunction
    extends AbstractSingleEncapsulatedExpression
    In the SELECT clause the result of a query may be the result of an aggregate function applied to a path expression. The following aggregate functions can be used in the SELECT clause of a query: AVG, COUNT, MAX, MIN, SUM.

    A single_valued_association_field is designated by the name of an association-field in a one-to-one or many-to-one relationship. The type of a single_valued_association_field and thus a single_valued_association_path_expression is the abstract schema type of the related entity.

    The argument to an aggregate function may be preceded by the keyword DISTINCT to specify that duplicate values are to be eliminated before the aggregate function is applied. Null values are eliminated before the aggregate function is applied, regardless of whether the keyword DISTINCT is specified.

    BNF: aggregate_expression ::= { AVG | MAX | MIN | SUM } ([DISTINCT] state_field_path_expression) | COUNT ([DISTINCT] identification_variable | state_field_path_expression | single_valued_object_path_expression)

    See Also:
    AvgFunction, CountFunction, MaxFunction, MinFunction, SumFunction
    Pascal Filion
    • Constructor Detail

      • AggregateFunction

        protected AggregateFunction​(AbstractExpression parent,
                                    java.lang.String identifier)
        Creates a new AggregateFunction.
        parent - The parent of this expression
        identifier - The JPQL identifier that starts this expression
    • Method Detail

      • getActualDistinctIdentifier

        public java.lang.String getActualDistinctIdentifier()
        Returns the actual DISTINCT identifier found in the string representation of the JPQL query, which has the actual case that was used.
        The DISTINCT identifier that was actually parsed, or an empty string if it was not parsed
      • hasDistinct

        public final boolean hasDistinct()
        Determines whether the DISTINCT identifier was specified in the query.
        true if the query has DISTINCT; false otherwise
      • hasSpaceAfterDistinct

        public final boolean hasSpaceAfterDistinct()
        Determines whether a whitespace was parsed after DISTINCT.
        true if there was a whitespace after DISTINCT; false otherwise
      • parseEncapsulatedExpression

        protected final void parseEncapsulatedExpression​(WordParser wordParser,
                                                         int whitespaceCount,
                                                         boolean tolerant)
        Parses the encapsulated expression by starting at the current position, which is part of the given WordParser.
        parseEncapsulatedExpression in class AbstractSingleEncapsulatedExpression
        wordParser - The text to parse based on the current position of the cursor
        whitespaceCount - The number of whitespace characters that were parsed after '('
        tolerant - Determines whether the parsing system should be tolerant, meaning if it should try to parse invalid or incomplete queries
      • toParsedTextEncapsulatedExpression

        protected void toParsedTextEncapsulatedExpression​(java.lang.StringBuilder writer,
                                                          boolean actual)
        Generates a string representation of the encapsulated Expression.
        toParsedTextEncapsulatedExpression in class AbstractSingleEncapsulatedExpression
        writer - The buffer used to append the encapsulated Expression's string representation
        actual - Determines whether to include any characters that are considered virtual, i.e. that was parsed when the query is incomplete and is needed for functionality like content assist