Class AbstractAggregate

All Implemented Interfaces:
HasSQL, Typed
Direct Known Subclasses:
Aggregate, JavaAggregate

public abstract class AbstractAggregate extends DataAnalysisOperation
A base class for aggregate functions.
  • Field Details

    • distinct

      protected final boolean distinct
      is this a DISTINCT aggregate
    • args

      protected final Expression[] args
      The arguments.
    • filterCondition

      protected Expression filterCondition
      FILTER condition for aggregate
    • type

      protected TypeInfo type
      The type of the result.
  • Constructor Details

    • AbstractAggregate

      AbstractAggregate(Select select, Expression[] args, boolean distinct)
  • Method Details

    • isAggregate

      public final boolean isAggregate()
      Description copied from class: DataAnalysisOperation
      Checks whether this expression is an aggregate function.
      Specified by:
      isAggregate in class DataAnalysisOperation
      Returns:
      true if this is an aggregate function (including aggregates with OVER clause), false if this is a window function
    • setFilterCondition

      public void setFilterCondition(Expression filterCondition)
      Sets the FILTER condition.
      Parameters:
      filterCondition - FILTER condition
    • getType

      public TypeInfo getType()
      Description copied from class: Expression
      Returns the data type. The data type may be unknown before the optimization phase.
      Specified by:
      getType in interface Typed
      Specified by:
      getType in class Expression
      Returns:
      the data type
    • mapColumnsAnalysis

      public void mapColumnsAnalysis(ColumnResolver resolver, int level, int innerState)
      Description copied from class: DataAnalysisOperation
      Map the columns of the resolver to expression columns.
      Overrides:
      mapColumnsAnalysis in class DataAnalysisOperation
      Parameters:
      resolver - the column resolver
      level - the subquery nesting level
      innerState - one of the Expression MAP_IN_* values
    • optimize

      public Expression optimize(SessionLocal session)
      Description copied from class: Expression
      Try to optimize the expression.
      Overrides:
      optimize in class DataAnalysisOperation
      Parameters:
      session - the session
      Returns:
      the optimized expression
    • setEvaluatable

      public void setEvaluatable(TableFilter tableFilter, boolean b)
      Description copied from class: Expression
      Tell the expression columns whether the table filter can return values now. This is used when optimizing the query.
      Overrides:
      setEvaluatable in class DataAnalysisOperation
      Parameters:
      tableFilter - the table filter
      b - true if the table filter can return value
    • getOrderedResultLoop

      protected void getOrderedResultLoop(SessionLocal session, HashMap<Integer,Value> result, ArrayList<Value[]> ordered, int rowIdColumn)
      Description copied from class: DataAnalysisOperation
      Returns result of this window function or window aggregate. This method may not be called on window aggregate without window order clause.
      Specified by:
      getOrderedResultLoop in class DataAnalysisOperation
      Parameters:
      session - the session
      result - the map to append result to
      ordered - ordered data
      rowIdColumn - the index of row id value
    • checkVariableBounds

      private static boolean checkVariableBounds(WindowFrame frame, ArrayList<Value[]> ordered)
    • aggregateFastPartition

      private void aggregateFastPartition(SessionLocal session, HashMap<Integer,Value> result, ArrayList<Value[]> ordered, int rowIdColumn, boolean grouped)
    • aggregateFastPartitionInReverse

      private void aggregateFastPartitionInReverse(SessionLocal session, HashMap<Integer,Value> result, ArrayList<Value[]> ordered, int rowIdColumn, boolean grouped)
    • processGroup

      private int processGroup(HashMap<Integer,Value> result, Value r, ArrayList<Value[]> ordered, int rowIdColumn, int i, int size, boolean grouped)
    • aggregateWholePartition

      private void aggregateWholePartition(SessionLocal session, HashMap<Integer,Value> result, ArrayList<Value[]> ordered, int rowIdColumn)
    • updateFromExpressions

      protected abstract void updateFromExpressions(SessionLocal session, Object aggregateData, Value[] array)
      Updates the provided aggregate data from the remembered expressions.
      Parameters:
      session - the session
      aggregateData - aggregate data
      array - values of expressions
    • updateAggregate

      protected void updateAggregate(SessionLocal session, SelectGroups groupData, int groupRowId)
      Description copied from class: DataAnalysisOperation
      Update a row of an aggregate.
      Specified by:
      updateAggregate in class DataAnalysisOperation
      Parameters:
      session - the database session
      groupData - data for the aggregate group
      groupRowId - row id of group
    • updateAggregate

      protected abstract void updateAggregate(SessionLocal session, Object aggregateData)
      Updates an aggregate value.
      Parameters:
      session - the session
      aggregateData - aggregate data
    • updateGroupAggregates

      protected void updateGroupAggregates(SessionLocal session, int stage)
      Description copied from class: DataAnalysisOperation
      Invoked when processing group stage of grouped window queries to update arguments of this aggregate.
      Overrides:
      updateGroupAggregates in class DataAnalysisOperation
      Parameters:
      session - the session
      stage - select stage
    • appendTailConditions

      protected StringBuilder appendTailConditions(StringBuilder builder, int sqlFlags, boolean forceOrderBy)
      Description copied from class: DataAnalysisOperation
      Used to create SQL for the OVER and FILTER clauses.
      Overrides:
      appendTailConditions in class DataAnalysisOperation
      Parameters:
      builder - string builder
      sqlFlags - formatting flags
      forceOrderBy - whether synthetic ORDER BY clause should be generated when it is missing
      Returns:
      the builder object
    • getSubexpressionCount

      public int getSubexpressionCount()
      Description copied from class: Expression
      Returns count of subexpressions.
      Overrides:
      getSubexpressionCount in class Expression
      Returns:
      count of subexpressions
    • getSubexpression

      public Expression getSubexpression(int index)
      Description copied from class: Expression
      Returns subexpression with specified index.
      Overrides:
      getSubexpression in class Expression
      Parameters:
      index - 0-based index
      Returns:
      subexpression with specified index, may be null