com.hazelcast.jet.pipeline

Interface StageWithGroupingAndWindow<T,K>

Type Parameters:

T - type of the input item

K - type of the key

public interface StageWithGroupingAndWindow<T,K>

Represents an intermediate step in the construction of a pipeline stage that performs a windowed group-and-aggregate operation. It captures the grouping key and the window definition, and offers the methods to finalize the construction by specifying the aggregate operation and any additional pipeline stages contributing their data to a co-group-and-aggregate stage.

Method Summary

Modifier and Type	Method and Description
<A,R> StreamStage<TimestampedEntry<K,R>>	aggregate(AggregateOperation1<? super T,A,R> aggrOp) Attaches to this stage a stage that performs the given group-and-aggregate operation.
<A,R,OUT> StreamStage<OUT>	aggregate(AggregateOperation1<? super T,A,R> aggrOp, KeyedWindowResultFunction<? super K,? super R,OUT> mapToOutputFn) Attaches to this stage a stage that performs the given group-and-aggregate operation over the window described by the window definition captured by this object.
<T1,A,R> StreamStage<TimestampedEntry<K,R>>	aggregate2(StreamStageWithGrouping<T1,? extends K> stage1, AggregateOperation2<? super T,? super T1,A,R> aggrOp) Attaches to this stage a stage that performs the given cogroup-and-aggregate operation over the items from both this stage and stage1 you supply.
<T1,A,R,OUT> StreamStage<OUT>	aggregate2(StreamStageWithGrouping<T1,? extends K> stage1, AggregateOperation2<? super T,? super T1,A,R> aggrOp, KeyedWindowResultFunction<? super K,? super R,OUT> mapToOutputFn) Attaches to this stage a stage that performs the given cogroup-and-aggregate operation over the items from both this stage and stage1 you supply.
<T1,T2,A,R> StreamStage<TimestampedEntry<K,R>>	aggregate3(StreamStageWithGrouping<T1,? extends K> stage1, StreamStageWithGrouping<T2,? extends K> stage2, AggregateOperation3<? super T,? super T1,? super T2,A,R> aggrOp) Attaches to this stage a stage that performs the given cogroup-and-aggregate operation over the items from this stage as well as stage1 and stage2 you supply.
<T1,T2,A,R,OUT> StreamStage<OUT>	aggregate3(StreamStageWithGrouping<T1,? extends K> stage1, StreamStageWithGrouping<T2,? extends K> stage2, AggregateOperation3<? super T,? super T1,? super T2,A,R> aggrOp, KeyedWindowResultFunction<? super K,? super R,OUT> mapToOutputFn) Attaches to this stage a stage that performs the given cogroup-and-aggregate operation over the items from this stage as well as stage1 and stage2 you supply.
default WindowGroupAggregateBuilder<T,K>	aggregateBuilder() Returns a fluent API builder object to construct a windowed cogroup-and-aggregate stage with any number of contributing stages.
DistributedFunction<? super T,? extends K>	keyFn() Returns the function that extracts the grouping key from stream items.
WindowDefinition	windowDefinition() Returns the definition of the window for the windowed aggregation operation that you are about to construct using this object.

Method Detail

keyFn

@Nonnull
DistributedFunction<? super T,? extends K> keyFn()

Returns the function that extracts the grouping key from stream items. This function will be used in the aggregating stage you are about to construct using this object.

windowDefinition

@Nonnull
WindowDefinition windowDefinition()

Returns the definition of the window for the windowed aggregation operation that you are about to construct using this object.

aggregate

@Nonnull
<A,R,OUT> StreamStage<OUT> aggregate(@Nonnull
                                              AggregateOperation1<? super T,A,R> aggrOp,
                                              @Nonnull
                                              KeyedWindowResultFunction<? super K,? super R,OUT> mapToOutputFn)

Attaches to this stage a stage that performs the given group-and-aggregate operation over the window described by the window definition captured by this object. For each distinct grouping key it observes in the input belonging to a given window, it performs the supplied aggregate operation across all the items sharing that key. Once it has received all the items, it calls the supplied mapToOutputFn with each key and the associated aggregation result to create the items to emit.

Type Parameters:

A - type of the accumulator used by the aggregate operation

R - type of the aggregation result

OUT - type of the output item

Parameters:

aggrOp - the aggregate operation to perform

mapToOutputFn - the function that creates the output item

See Also:

AggregateOperations

aggregate

@Nonnull
<A,R> StreamStage<TimestampedEntry<K,R>> aggregate(@Nonnull
                                                            AggregateOperation1<? super T,A,R> aggrOp)

Attaches to this stage a stage that performs the given group-and-aggregate operation. It emits one key-value pair (in a Map.Entry) for each distinct key it observes in its input belonging to a given window. The value is the result of the aggregate operation across all the items with the given grouping key.

Type Parameters:

A - type of the accumulator used by the aggregate operation

R - type of the aggregation result

Parameters:

aggrOp - the aggregate operation to perform

See Also:

AggregateOperations

aggregate2

@Nonnull
<T1,A,R,OUT> StreamStage<OUT> aggregate2(@Nonnull
                                                  StreamStageWithGrouping<T1,? extends K> stage1,
                                                  @Nonnull
                                                  AggregateOperation2<? super T,? super T1,A,R> aggrOp,
                                                  @Nonnull
                                                  KeyedWindowResultFunction<? super K,? super R,OUT> mapToOutputFn)

Attaches to this stage a stage that performs the given cogroup-and-aggregate operation over the items from both this stage and stage1 you supply. For each distinct grouping key it observes in the input belonging to a given window, it performs the supplied aggregate operation across all the items sharing that key. Once it has received all the items, it calls the supplied mapToOutputFn with each key and the associated aggregation result to create the items to emit.

Type Parameters:

T1 - type of items in stage1

A - type of the accumulator used by the aggregate operation

R - type of the aggregation result

OUT - type of the output item

Parameters:

aggrOp - the aggregate operation to perform

mapToOutputFn - the function that creates the output item

See Also:

AggregateOperations The aggregate operation must specify a separate accumulator function for each of the two streams (refer to its {@link AggregateOperation2 Javadoc} for a simple example)., AggregateOperations

aggregate2

@Nonnull
<T1,A,R> StreamStage<TimestampedEntry<K,R>> aggregate2(@Nonnull
                                                                StreamStageWithGrouping<T1,? extends K> stage1,
                                                                @Nonnull
                                                                AggregateOperation2<? super T,? super T1,A,R> aggrOp)

Attaches to this stage a stage that performs the given cogroup-and-aggregate operation over the items from both this stage and stage1 you supply. It emits one key-value pair (in a Map.Entry) for each distinct key it observes in the input belonging to a given window. The value is the result of the aggregate operation across all the items with the given grouping key.

The aggregate operation must specify a separate accumulator function for each of the two streams (refer to its Javadoc for a simple example).

Type Parameters:

T1 - type of items in stage1

A - type of the accumulator used by the aggregate operation

R - type of the aggregation result

Parameters:

aggrOp - the aggregate operation to perform

See Also:

AggregateOperations

aggregate3

@Nonnull
<T1,T2,A,R,OUT> StreamStage<OUT> aggregate3(@Nonnull
                                                     StreamStageWithGrouping<T1,? extends K> stage1,
                                                     @Nonnull
                                                     StreamStageWithGrouping<T2,? extends K> stage2,
                                                     @Nonnull
                                                     AggregateOperation3<? super T,? super T1,? super T2,A,R> aggrOp,
                                                     @Nonnull
                                                     KeyedWindowResultFunction<? super K,? super R,OUT> mapToOutputFn)

Attaches to this stage a stage that performs the given cogroup-and-aggregate operation over the items from this stage as well as stage1 and stage2 you supply. For each distinct grouping key it observes in the input belonging to a given window, it performs the supplied aggregate operation across all the items sharing that key. Once it has received all the items, it calls the supplied mapToOutputFn with each key and the associated aggregation result to create the items to emit.

The aggregate operation must specify a separate accumulator function for each of the three streams (refer to its Javadoc for a simple example).

Type Parameters:

T1 - type of items in stage1

T2 - type of items in stage2

A - type of the accumulator used by the aggregate operation

R - type of the aggregation result

OUT - type of the output item

Parameters:

aggrOp - the aggregate operation to perform

mapToOutputFn - the function that creates the output item

See Also:

AggregateOperations

aggregate3

@Nonnull
<T1,T2,A,R> StreamStage<TimestampedEntry<K,R>> aggregate3(@Nonnull
                                                                   StreamStageWithGrouping<T1,? extends K> stage1,
                                                                   @Nonnull
                                                                   StreamStageWithGrouping<T2,? extends K> stage2,
                                                                   @Nonnull
                                                                   AggregateOperation3<? super T,? super T1,? super T2,A,R> aggrOp)

Attaches to this stage a stage that performs the given cogroup-and-aggregate operation over the items from this stage as well as stage1 and stage2 you supply. It emits one key-value pair (in a Map.Entry) for each distinct key it observes in the input belonging to a given window. The value is the result of the aggregate operation across all the items with the given grouping key.

The aggregate operation must specify a separate accumulator function for each of the three streams (refer to its Javadoc for a simple example).

Type Parameters:

T1 - type of items in stage1

T2 - type of items in stage2

A - type of the accumulator used by the aggregate operation

R - type of the aggregation result

Parameters:

aggrOp - the aggregate operation to perform

See Also:

AggregateOperations

aggregateBuilder

@Nonnull
default WindowGroupAggregateBuilder<T,K> aggregateBuilder()

Returns a fluent API builder object to construct a windowed cogroup-and-aggregate stage with any number of contributing stages. It is mainly intended to co-group four or more stages. For up to three stages prefer the direct stage.aggregateN(...) calls because they offer more static type safety.