org.apache.flink.table.functions

Class AggregateFunction<T,ACC>

java.lang.Object

org.apache.flink.table.functions.UserDefinedFunction

org.apache.flink.table.functions.UserDefinedAggregateFunction<T,ACC>

org.apache.flink.table.functions.AggregateFunction<T,ACC>

Type Parameters:

T - the type of the aggregation result

ACC - the type of the aggregation accumulator. The accumulator is used to keep the aggregated values which are needed to compute an aggregation result. AggregateFunction represents its state using accumulator, thereby the state of the AggregateFunction must be put into the accumulator.

All Implemented Interfaces:

Serializable, FunctionDefinition

@PublicEvolving
public abstract class AggregateFunction<T,ACC>
extends UserDefinedAggregateFunction<T,ACC>

Base class for user-defined aggregates.

The behavior of an AggregateFunction can be defined by implementing a series of custom methods. An AggregateFunction needs at least three methods:

• createAccumulator
• accumulate
• getValue

There are a few other methods that can be optional to have:

• retract
• merge
• resetAccumulator

All these methods must be declared publicly, not static, and named exactly as the names mentioned above. The method UserDefinedAggregateFunction.createAccumulator() is defined in the UserDefinedAggregateFunction function, and method getValue(ACC) is defined in the AggregateFunction while other methods are explained below.

 
 Processes the input values and update the provided accumulator instance. The method
 accumulate can be overloaded with different custom types and arguments. An AggregateFunction
 requires at least one accumulate() method.

 param: accumulator           the accumulator which contains the current aggregated results
 param: [user defined inputs] the input value (usually obtained from a new arrived data).

 public void accumulate(ACC accumulator, [user defined inputs])
 
 

 
 Retracts the input values from the accumulator instance. The current design assumes the
 inputs are the values that have been previously accumulated. The method retract can be
 overloaded with different custom types and arguments. This function must be implemented for
 data stream bounded OVER aggregates.

 param: accumulator           the accumulator which contains the current aggregated results
 param: [user defined inputs] the input value (usually obtained from a new arrived data).

 public void retract(ACC accumulator, [user defined inputs])
 
 

 
 Merges a group of accumulator instances into one accumulator instance. This function must be
 implemented for data stream session window grouping aggregates and data set grouping aggregates.

 param: accumulator the accumulator which will keep the merged aggregate results. It should
                    be noted that the accumulator may contain the previous aggregated
                    results. Therefore user should not replace or clean this instance in the
                    custom merge method.
 param: its         an java.lang.Iterable pointed to a group of accumulators that will be
                    merged.

 public void merge(ACC accumulator, java.lang.Iterable<ACC> iterable)
 
 

 
 Resets the accumulator for this AggregateFunction. This function must be implemented for
 data set grouping aggregates.

 param: accumulator the accumulator which needs to be reset

 public void resetAccumulator(ACC accumulator)
 
 

If this aggregate function can only be applied in an OVER window, this can be declared using the requirement FunctionRequirement.OVER_WINDOW_ONLY in getRequirements().

See Also:

Serialized Form

Constructor Summary

Constructors

Constructor and Description
AggregateFunction()

Method Summary

Modifier and Type	Method and Description
FunctionKind	getKind() Returns the kind of function this definition describes.
Set<FunctionRequirement>	getRequirements() Returns the set of requirements this definition demands.
abstract T	getValue(ACC accumulator) Called every time when an aggregation result should be materialized.
boolean	requiresOver() Deprecated. Use getRequirements() instead.

Methods inherited from class org.apache.flink.table.functions.UserDefinedAggregateFunction

createAccumulator, getAccumulatorType, getResultType

Methods inherited from class org.apache.flink.table.functions.UserDefinedFunction

close, functionIdentifier, open, toString

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.apache.flink.table.functions.FunctionDefinition

isDeterministic

Constructor Detail

AggregateFunction

public AggregateFunction()

Method Detail

getValue

public abstract T getValue(ACC accumulator)

Called every time when an aggregation result should be materialized. The returned value could be either an early and incomplete result (periodically emitted as data arrive) or the final result of the aggregation.

Parameters:

accumulator - the accumulator which contains the current aggregated results

Returns:

the aggregation result

requiresOver

@Deprecated
public boolean requiresOver()

Deprecated. Use getRequirements() instead.

Returns true if this AggregateFunction can only be applied in an OVER window.

Returns:

true if the AggregateFunction requires an OVER window, false otherwise.

getKind

public final FunctionKind getKind()

Description copied from interface: FunctionDefinition

Returns the kind of function this definition describes.

getRequirements

public Set<FunctionRequirement> getRequirements()

Description copied from interface: FunctionDefinition

Returns the set of requirements this definition demands.