Package | Description |
---|---|
com.hazelcast.jet.aggregate |
Contains
AggregateOperation and its several variants, as well
as a builder object for the aggregate operations. |
com.hazelcast.jet.pipeline |
The Pipeline API is Jet's high-level API to build and execute
distributed computation jobs.
|
Modifier and Type | Method and Description |
---|---|
static <T,A0,A1,A2,R0,R1,R2> |
AggregateOperations.allOf(AggregateOperation1<? super T,A0,? extends R0> op0,
AggregateOperation1<? super T,A1,? extends R1> op1,
AggregateOperation1<? super T,A2,? extends R2> op2)
Convenience for
AggregateOperations.allOf(AggregateOperation1, AggregateOperation1,
AggregateOperation1, TriFunction) wrapping the three results in a
Tuple3 . |
static <T,A0,A1,A2,R0,R1,R2,R> |
AggregateOperations.allOf(AggregateOperation1<? super T,A0,? extends R0> op0,
AggregateOperation1<? super T,A1,? extends R1> op1,
AggregateOperation1<? super T,A2,? extends R2> op2,
TriFunction<? super R0,? super R1,? super R2,? extends R> exportFinishFn)
Returns an aggregate operation that is a composite of three aggregate
operations.
|
static <T,A0,A1,R0,R1,R> |
AggregateOperations.allOf(AggregateOperation1<? super T,A0,? extends R0> op0,
AggregateOperation1<? super T,A1,? extends R1> op1,
BiFunctionEx<? super R0,? super R1,? extends R> exportFinishFn)
Returns an aggregate operation that is a composite of two aggregate
operations.
|
static <T,A0,A1,R0,R1> |
AggregateOperations.allOf(AggregateOperation1<? super T,A0,R0> op1,
AggregateOperation1<? super T,A1,R1> op2)
Convenience for
AggregateOperations.allOf(AggregateOperation1, AggregateOperation1,
BiFunctionEx) wrapping the two results in a Tuple2 . |
<R_NEW> AggregateOperation1<T0,A,R_NEW> |
AggregateOperationBuilder.Arity1.andExportFinish(FunctionEx<? super A,? extends R_NEW> exportFinishFn)
|
AggregateOperation1<T0,A,R> |
AggregateOperationBuilder.Arity1.andFinish(FunctionEx<? super A,? extends R> finishFn)
Registers the
finish primitive. |
<R_NEW> AggregateOperation1<T,A,R_NEW> |
AggregateOperation1.andThen(FunctionEx<? super R,? extends R_NEW> thenFn) |
static <T> AggregateOperation1<T,LongDoubleAccumulator,Double> |
AggregateOperations.averagingDouble(ToDoubleFunctionEx<? super T> getDoubleValueFn)
Returns an aggregate operation that finds the arithmetic mean (aka.
|
static <T> AggregateOperation1<T,LongLongAccumulator,Double> |
AggregateOperations.averagingLong(ToLongFunctionEx<? super T> getLongValueFn)
Returns an aggregate operation that finds the arithmetic mean (aka.
|
static <T> AggregateOperation1<T,PriorityQueue<T>,List<T>> |
AggregateOperations.bottomN(int n,
ComparatorEx<? super T> comparator)
Returns an aggregate operation that finds the bottom
n items
according to the given comparator . |
AggregateOperation1<T,Object[],ItemsByTag> |
AllOfAggregationBuilder.build()
Builds and returns the composite
AggregateOperation1 . |
<R> AggregateOperation1<T,Object[],R> |
AllOfAggregationBuilder.build(FunctionEx<ItemsByTag,R> exportFinishFn)
Builds and returns the composite
AggregateOperation1 . |
static AggregateOperation1<CharSequence,StringBuilder,String> |
AggregateOperations.concatenating()
Returns an aggregate operation that takes string items and concatenates
them into a single string.
|
static AggregateOperation1<CharSequence,StringBuilder,String> |
AggregateOperations.concatenating(CharSequence delimiter)
Returns an aggregate operation that takes string items and concatenates
them, separated by the given
delimiter , into a single string. |
static AggregateOperation1<CharSequence,StringBuilder,String> |
AggregateOperations.concatenating(CharSequence delimiter,
CharSequence prefix,
CharSequence suffix)
Returns an aggregate operation that takes string items and concatenates
them, separated by the given
delimiter , into a single string. |
static <T> AggregateOperation1<T,LongAccumulator,Long> |
AggregateOperations.counting()
Returns an aggregate operation that counts the items it observes.
|
static <T,A,R> AggregateOperation1<T,A,R> |
AggregateOperations.filtering(PredicateEx<? super T> filterFn,
AggregateOperation1<? super T,A,? extends R> downstream)
Adapts an aggregate operation so that it accumulates only the items
passing the
filterFn and ignores others. |
static <T,U,A,R> AggregateOperation1<T,A,R> |
AggregateOperations.flatMapping(FunctionEx<? super T,? extends Traverser<? extends U>> flatMapFn,
AggregateOperation1<? super U,A,? extends R> downstream)
Adapts an aggregate operation that takes items of type
U to one
that takes items of type T , by exploding each T into a
sequence of U s and then accumulating all of them. |
static <T,K> AggregateOperation1<T,Map<K,List<T>>,Map<K,List<T>>> |
AggregateOperations.groupingBy(FunctionEx<? super T,? extends K> keyFn)
Returns an aggregate operation that accumulates the items into a
HashMap where the key is the result of applying keyFn
and the value is a list of the items with that key. |
static <T,K,A,R> AggregateOperation1<T,Map<K,A>,Map<K,R>> |
AggregateOperations.groupingBy(FunctionEx<? super T,? extends K> keyFn,
AggregateOperation1<? super T,A,R> downstream)
Returns an aggregate operation that accumulates the items into a
HashMap where the key is the result of applying keyFn
and the value is the result of applying the downstream aggregate
operation to the items with that key. |
static <T,K,R,A,M extends Map<K,R>> |
AggregateOperations.groupingBy(FunctionEx<? super T,? extends K> keyFn,
SupplierEx<M> createMapFn,
AggregateOperation1<? super T,A,R> downstream)
Returns an
AggregateOperation1 that accumulates the items into a
Map (as obtained from createMapFn ) where the key is the
result of applying keyFn and the value is the result of
applying the downstream aggregate operation to the items with that key. |
static <T> AggregateOperation1<T,LinTrendAccumulator,Double> |
AggregateOperations.linearTrend(ToLongFunctionEx<T> getXFn,
ToLongFunctionEx<T> getYFn)
Returns an aggregate operation that computes a linear trend over the
items.
|
static <T,U,A,R> AggregateOperation1<T,A,R> |
AggregateOperations.mapping(FunctionEx<? super T,? extends U> mapFn,
AggregateOperation1<? super U,A,? extends R> downstream)
Adapts an aggregate operation that takes items of type
U to one
that takes items of type T , by applying the given mapping
function to each item. |
static <T> AggregateOperation1<T,MutableReference<T>,T> |
AggregateOperations.maxBy(ComparatorEx<? super T> comparator)
Returns an aggregate operation that computes the greatest item according
to the given
comparator . |
static <T> AggregateOperation1<T,MutableReference<T>,T> |
AggregateOperations.minBy(ComparatorEx<? super T> comparator)
Returns an aggregate operation that computes the least item according to
the given
comparator . |
static <T> AggregateOperation1<T,PickAnyAccumulator<T>,T> |
AggregateOperations.pickAny()
Returns an aggregate operation whose result is an arbitrary item it
observed, or
null if it observed no items. |
static <T,A> AggregateOperation1<T,MutableReference<A>,A> |
AggregateOperations.reducing(A emptyAccValue,
FunctionEx<? super T,? extends A> toAccValueFn,
BinaryOperatorEx<A> combineAccValuesFn,
BinaryOperatorEx<A> deductAccValueFn)
Returns an aggregate operation that constructs the result through the
process of immutable reduction:
The initial accumulated value is
emptyAccValue . |
static <T> AggregateOperation1<T,ArrayList<T>,List<T>> |
AggregateOperations.sorting(ComparatorEx<? super T> comparator)
Returns an aggregate operation that accumulates all input items into an
ArrayList and sorts it with the given comparator. |
static <T> AggregateOperation1<T,DoubleAccumulator,Double> |
AggregateOperations.summingDouble(ToDoubleFunctionEx<? super T> getDoubleValueFn)
Returns an aggregate operation that computes the sum of the
double values it obtains by applying getDoubleValueFn to each
item. |
static <T> AggregateOperation1<T,LongAccumulator,Long> |
AggregateOperations.summingLong(ToLongFunctionEx<? super T> getLongValueFn)
Returns an aggregate operation that computes the sum of the
long
values it obtains by applying getLongValueFn to each item. |
static <T,C extends Collection<T>> |
AggregateOperations.toCollection(SupplierEx<C> createCollectionFn)
Returns an aggregate operation that accumulates the items into a
Collection . |
static <T> AggregateOperation1<T,List<T>,List<T>> |
AggregateOperations.toList()
Returns an aggregate operation that accumulates the items into an
ArrayList . |
static <T,K,U> AggregateOperation1<T,Map<K,U>,Map<K,U>> |
AggregateOperations.toMap(FunctionEx<? super T,? extends K> keyFn,
FunctionEx<? super T,? extends U> valueFn)
Returns an aggregate operation that accumulates the items into a
HashMap whose keys and values are the result of applying the provided
mapping functions. |
static <T,K,U> AggregateOperation1<T,Map<K,U>,Map<K,U>> |
AggregateOperations.toMap(FunctionEx<? super T,? extends K> keyFn,
FunctionEx<? super T,? extends U> valueFn,
BinaryOperatorEx<U> mergeFn)
Returns an aggregate operation that accumulates the items into a
HashMap whose keys and values are the result of applying
the provided mapping functions. |
static <T,K,U,M extends Map<K,U>> |
AggregateOperations.toMap(FunctionEx<? super T,? extends K> keyFn,
FunctionEx<? super T,? extends U> valueFn,
BinaryOperatorEx<U> mergeFn,
SupplierEx<M> createMapFn)
Returns an aggregate operation that accumulates elements into a
user-supplied
Map instance. |
static <T> AggregateOperation1<T,PriorityQueue<T>,List<T>> |
AggregateOperations.topN(int n,
ComparatorEx<? super T> comparator)
Returns an aggregate operation that finds the top
n items
according to the given comparator . |
static <T> AggregateOperation1<T,Set<T>,Set<T>> |
AggregateOperations.toSet()
Returns an aggregate operation that accumulates the items into a
HashSet . |
<NEW_T> AggregateOperation1<NEW_T,A,R> |
AggregateOperation1.withAccumulateFn(BiConsumerEx<? super A,? super NEW_T> accumulateFn)
Returns a copy of this aggregate operation, but with the
accumulate primitive replaced with the one supplied here. |
default <T> AggregateOperation1<T,A,R> |
AggregateOperation.withCombiningAccumulateFn(FunctionEx<T,A> getAccFn)
Returns a copy of this aggregate operation, but with the
accumulate primitive replaced with one that expects to find accumulator
objects in the input items and combines them all into a single
accumulator of the same type. |
AggregateOperation1<T,A,A> |
AggregateOperation1.withIdentityFinish() |
Modifier and Type | Method and Description |
---|---|
<R> Tag<R> |
AllOfAggregationBuilder.add(AggregateOperation1<? super T,?,R> operation)
Adds the supplied aggregate operation to the composite.
|
<T,R> Tag<R> |
CoAggregateOperationBuilder.add(Tag<T> tag,
AggregateOperation1<? super T,?,? extends R> operation)
Registers the given aggregate operation with the tag corresponding to an
input to the co-aggregating operation being built.
|
static <T0,T1,A0,A1,R0,R1> |
AggregateOperations.aggregateOperation2(AggregateOperation1<? super T0,A0,? extends R0> op0,
AggregateOperation1<? super T1,A1,? extends R1> op1)
Convenience for
aggregateOperation2(aggrOp0, aggrOp1, finishFn) that outputs a
Tuple2(result0, result1) . |
static <T0,T1,A0,A1,R0,R1> |
AggregateOperations.aggregateOperation2(AggregateOperation1<? super T0,A0,? extends R0> op0,
AggregateOperation1<? super T1,A1,? extends R1> op1)
Convenience for
aggregateOperation2(aggrOp0, aggrOp1, finishFn) that outputs a
Tuple2(result0, result1) . |
static <T0,A0,R0,T1,A1,R1,R> |
AggregateOperations.aggregateOperation2(AggregateOperation1<? super T0,A0,? extends R0> op0,
AggregateOperation1<? super T1,A1,? extends R1> op1,
BiFunctionEx<? super R0,? super R1,? extends R> exportFinishFn)
Returns an aggregate operation that is a composite of two independent
aggregate operations, each one accepting its own input.
|
static <T0,A0,R0,T1,A1,R1,R> |
AggregateOperations.aggregateOperation2(AggregateOperation1<? super T0,A0,? extends R0> op0,
AggregateOperation1<? super T1,A1,? extends R1> op1,
BiFunctionEx<? super R0,? super R1,? extends R> exportFinishFn)
Returns an aggregate operation that is a composite of two independent
aggregate operations, each one accepting its own input.
|
static <T0,T1,T2,A0,A1,A2,R0,R1,R2> |
AggregateOperations.aggregateOperation3(AggregateOperation1<? super T0,A0,? extends R0> op0,
AggregateOperation1<? super T1,A1,? extends R1> op1,
AggregateOperation1<? super T2,A2,? extends R2> op2)
Convenience for
aggregateOperation3(aggrOp0, aggrOp1, aggrOp2, finishFn) that outputs a
Tuple3(result0, result1, result2) . |
static <T0,T1,T2,A0,A1,A2,R0,R1,R2> |
AggregateOperations.aggregateOperation3(AggregateOperation1<? super T0,A0,? extends R0> op0,
AggregateOperation1<? super T1,A1,? extends R1> op1,
AggregateOperation1<? super T2,A2,? extends R2> op2)
Convenience for
aggregateOperation3(aggrOp0, aggrOp1, aggrOp2, finishFn) that outputs a
Tuple3(result0, result1, result2) . |
static <T0,T1,T2,A0,A1,A2,R0,R1,R2> |
AggregateOperations.aggregateOperation3(AggregateOperation1<? super T0,A0,? extends R0> op0,
AggregateOperation1<? super T1,A1,? extends R1> op1,
AggregateOperation1<? super T2,A2,? extends R2> op2)
Convenience for
aggregateOperation3(aggrOp0, aggrOp1, aggrOp2, finishFn) that outputs a
Tuple3(result0, result1, result2) . |
static <T0,T1,T2,A0,A1,A2,R0,R1,R2,R> |
AggregateOperations.aggregateOperation3(AggregateOperation1<? super T0,A0,? extends R0> op0,
AggregateOperation1<? super T1,A1,? extends R1> op1,
AggregateOperation1<? super T2,A2,? extends R2> op2,
TriFunction<? super R0,? super R1,? super R2,? extends R> exportFinishFn)
Returns an aggregate operation that is a composite of three independent
aggregate operations, each one accepting its own input.
|
static <T0,T1,T2,A0,A1,A2,R0,R1,R2,R> |
AggregateOperations.aggregateOperation3(AggregateOperation1<? super T0,A0,? extends R0> op0,
AggregateOperation1<? super T1,A1,? extends R1> op1,
AggregateOperation1<? super T2,A2,? extends R2> op2,
TriFunction<? super R0,? super R1,? super R2,? extends R> exportFinishFn)
Returns an aggregate operation that is a composite of three independent
aggregate operations, each one accepting its own input.
|
static <T0,T1,T2,A0,A1,A2,R0,R1,R2,R> |
AggregateOperations.aggregateOperation3(AggregateOperation1<? super T0,A0,? extends R0> op0,
AggregateOperation1<? super T1,A1,? extends R1> op1,
AggregateOperation1<? super T2,A2,? extends R2> op2,
TriFunction<? super R0,? super R1,? super R2,? extends R> exportFinishFn)
Returns an aggregate operation that is a composite of three independent
aggregate operations, each one accepting its own input.
|
static <T,A0,A1,A2,R0,R1,R2> |
AggregateOperations.allOf(AggregateOperation1<? super T,A0,? extends R0> op0,
AggregateOperation1<? super T,A1,? extends R1> op1,
AggregateOperation1<? super T,A2,? extends R2> op2)
Convenience for
AggregateOperations.allOf(AggregateOperation1, AggregateOperation1,
AggregateOperation1, TriFunction) wrapping the three results in a
Tuple3 . |
static <T,A0,A1,A2,R0,R1,R2> |
AggregateOperations.allOf(AggregateOperation1<? super T,A0,? extends R0> op0,
AggregateOperation1<? super T,A1,? extends R1> op1,
AggregateOperation1<? super T,A2,? extends R2> op2)
Convenience for
AggregateOperations.allOf(AggregateOperation1, AggregateOperation1,
AggregateOperation1, TriFunction) wrapping the three results in a
Tuple3 . |
static <T,A0,A1,A2,R0,R1,R2> |
AggregateOperations.allOf(AggregateOperation1<? super T,A0,? extends R0> op0,
AggregateOperation1<? super T,A1,? extends R1> op1,
AggregateOperation1<? super T,A2,? extends R2> op2)
Convenience for
AggregateOperations.allOf(AggregateOperation1, AggregateOperation1,
AggregateOperation1, TriFunction) wrapping the three results in a
Tuple3 . |
static <T,A0,A1,A2,R0,R1,R2,R> |
AggregateOperations.allOf(AggregateOperation1<? super T,A0,? extends R0> op0,
AggregateOperation1<? super T,A1,? extends R1> op1,
AggregateOperation1<? super T,A2,? extends R2> op2,
TriFunction<? super R0,? super R1,? super R2,? extends R> exportFinishFn)
Returns an aggregate operation that is a composite of three aggregate
operations.
|
static <T,A0,A1,A2,R0,R1,R2,R> |
AggregateOperations.allOf(AggregateOperation1<? super T,A0,? extends R0> op0,
AggregateOperation1<? super T,A1,? extends R1> op1,
AggregateOperation1<? super T,A2,? extends R2> op2,
TriFunction<? super R0,? super R1,? super R2,? extends R> exportFinishFn)
Returns an aggregate operation that is a composite of three aggregate
operations.
|
static <T,A0,A1,A2,R0,R1,R2,R> |
AggregateOperations.allOf(AggregateOperation1<? super T,A0,? extends R0> op0,
AggregateOperation1<? super T,A1,? extends R1> op1,
AggregateOperation1<? super T,A2,? extends R2> op2,
TriFunction<? super R0,? super R1,? super R2,? extends R> exportFinishFn)
Returns an aggregate operation that is a composite of three aggregate
operations.
|
static <T,A0,A1,R0,R1,R> |
AggregateOperations.allOf(AggregateOperation1<? super T,A0,? extends R0> op0,
AggregateOperation1<? super T,A1,? extends R1> op1,
BiFunctionEx<? super R0,? super R1,? extends R> exportFinishFn)
Returns an aggregate operation that is a composite of two aggregate
operations.
|
static <T,A0,A1,R0,R1,R> |
AggregateOperations.allOf(AggregateOperation1<? super T,A0,? extends R0> op0,
AggregateOperation1<? super T,A1,? extends R1> op1,
BiFunctionEx<? super R0,? super R1,? extends R> exportFinishFn)
Returns an aggregate operation that is a composite of two aggregate
operations.
|
static <T,A0,A1,R0,R1> |
AggregateOperations.allOf(AggregateOperation1<? super T,A0,R0> op1,
AggregateOperation1<? super T,A1,R1> op2)
Convenience for
AggregateOperations.allOf(AggregateOperation1, AggregateOperation1,
BiFunctionEx) wrapping the two results in a Tuple2 . |
static <T,A0,A1,R0,R1> |
AggregateOperations.allOf(AggregateOperation1<? super T,A0,R0> op1,
AggregateOperation1<? super T,A1,R1> op2)
Convenience for
AggregateOperations.allOf(AggregateOperation1, AggregateOperation1,
BiFunctionEx) wrapping the two results in a Tuple2 . |
static <T,A,R> AggregateOperation1<T,A,R> |
AggregateOperations.filtering(PredicateEx<? super T> filterFn,
AggregateOperation1<? super T,A,? extends R> downstream)
Adapts an aggregate operation so that it accumulates only the items
passing the
filterFn and ignores others. |
static <T,U,A,R> AggregateOperation1<T,A,R> |
AggregateOperations.flatMapping(FunctionEx<? super T,? extends Traverser<? extends U>> flatMapFn,
AggregateOperation1<? super U,A,? extends R> downstream)
Adapts an aggregate operation that takes items of type
U to one
that takes items of type T , by exploding each T into a
sequence of U s and then accumulating all of them. |
static <T,K,A,R> AggregateOperation1<T,Map<K,A>,Map<K,R>> |
AggregateOperations.groupingBy(FunctionEx<? super T,? extends K> keyFn,
AggregateOperation1<? super T,A,R> downstream)
Returns an aggregate operation that accumulates the items into a
HashMap where the key is the result of applying keyFn
and the value is the result of applying the downstream aggregate
operation to the items with that key. |
static <T,K,R,A,M extends Map<K,R>> |
AggregateOperations.groupingBy(FunctionEx<? super T,? extends K> keyFn,
SupplierEx<M> createMapFn,
AggregateOperation1<? super T,A,R> downstream)
Returns an
AggregateOperation1 that accumulates the items into a
Map (as obtained from createMapFn ) where the key is the
result of applying keyFn and the value is the result of
applying the downstream aggregate operation to the items with that key. |
static <T,U,A,R> AggregateOperation1<T,A,R> |
AggregateOperations.mapping(FunctionEx<? super T,? extends U> mapFn,
AggregateOperation1<? super U,A,? extends R> downstream)
Adapts an aggregate operation that takes items of type
U to one
that takes items of type T , by applying the given mapping
function to each item. |
static <T,A,R> Aggregator<T,R> |
AggregateOperations.toAggregator(AggregateOperation1<? super T,A,? extends R> aggrOp)
Adapts this aggregate operation to be used for
IMap.aggregate(Aggregator)
calls. |
static <T,A,R> Collector<T,A,R> |
AggregateOperations.toCollector(AggregateOperation1<? super T,A,? extends R> aggrOp)
Adapts this aggregate operation to a collector which can be passed to
Stream.collect(Collector) . |
Modifier and Type | Method and Description |
---|---|
<T,R> Tag<R> |
AggregateBuilder.add(BatchStage<T> stage,
AggregateOperation1<? super T,?,? extends R> aggrOp)
Adds another stage that will contribute its data to the aggregate
operation to be performed.
|
<T,R> Tag<R> |
GroupAggregateBuilder.add(BatchStageWithKey<T,K> stage,
AggregateOperation1<? super T,?,? extends R> aggrOp)
Adds another stage that will contribute its data to the aggregate
operation to be performed.
|
<T,R> Tag<R> |
WindowAggregateBuilder.add(StreamStage<T> stage,
AggregateOperation1<? super T,?,? extends R> aggrOp)
Adds another stage that will contribute its data to the aggregate
operation to be performed.
|
<T,R> Tag<R> |
WindowGroupAggregateBuilder.add(StreamStageWithKey<T,K> stage,
AggregateOperation1<? super T,?,? extends R> aggrOp)
Adds another stage that will contribute its data to the windowed
group-and-aggregate stage being constructed.
|
<R> StreamStage<WindowResult<R>> |
StageWithWindow.aggregate(AggregateOperation1<? super T,?,? extends R> aggrOp)
Attaches a stage that performs the given aggregate operation over all
the items that belong to a given window.
|
<R> StreamStage<KeyedWindowResult<K,R>> |
StageWithKeyAndWindow.aggregate(AggregateOperation1<? super T,?,? extends R> aggrOp)
Attaches a stage that performs the given group-and-aggregate operation.
|
<R> BatchStage<R> |
BatchStage.aggregate(AggregateOperation1<? super T,?,? extends R> aggrOp)
Attaches a stage that performs the given aggregate operation over all
the items it receives.
|
<R> BatchStage<Map.Entry<K,R>> |
BatchStageWithKey.aggregate(AggregateOperation1<? super T,?,? extends R> aggrOp)
Attaches a stage that performs the given group-and-aggregate operation.
|
default <T1,R0,R1> BatchStage<Tuple2<R0,R1>> |
BatchStage.aggregate2(AggregateOperation1<? super T,?,? extends R0> aggrOp0,
BatchStage<T1> stage1,
AggregateOperation1<? super T1,?,? extends R1> aggrOp1)
Attaches a stage that co-aggregates the data from this and the supplied
stage by performing a separate aggregate operation on each and emits a
single
Tuple2 with their results. |
default <T1,R0,R1> BatchStage<Tuple2<R0,R1>> |
BatchStage.aggregate2(AggregateOperation1<? super T,?,? extends R0> aggrOp0,
BatchStage<T1> stage1,
AggregateOperation1<? super T1,?,? extends R1> aggrOp1)
Attaches a stage that co-aggregates the data from this and the supplied
stage by performing a separate aggregate operation on each and emits a
single
Tuple2 with their results. |
default <T1,R0,R1> BatchStage<Map.Entry<K,Tuple2<R0,R1>>> |
BatchStageWithKey.aggregate2(AggregateOperation1<? super T,?,? extends R0> aggrOp0,
BatchStageWithKey<? extends T1,? extends K> stage1,
AggregateOperation1<? super T1,?,? extends R1> aggrOp1)
Attaches a stage that performs the given cogroup-and-aggregate
transformation of the items from both this stage and
stage1
you supply. |
default <T1,R0,R1> BatchStage<Map.Entry<K,Tuple2<R0,R1>>> |
BatchStageWithKey.aggregate2(AggregateOperation1<? super T,?,? extends R0> aggrOp0,
BatchStageWithKey<? extends T1,? extends K> stage1,
AggregateOperation1<? super T1,?,? extends R1> aggrOp1)
Attaches a stage that performs the given cogroup-and-aggregate
transformation of the items from both this stage and
stage1
you supply. |
default <T1,R0,R1> StreamStage<WindowResult<Tuple2<R0,R1>>> |
StageWithWindow.aggregate2(AggregateOperation1<? super T,?,? extends R0> aggrOp0,
StreamStage<T1> stage1,
AggregateOperation1<? super T1,?,? extends R1> aggrOp1)
Attaches a stage that performs the given co-aggregate operations over
the items from this stage and
stage1 you supply. |
default <T1,R0,R1> StreamStage<WindowResult<Tuple2<R0,R1>>> |
StageWithWindow.aggregate2(AggregateOperation1<? super T,?,? extends R0> aggrOp0,
StreamStage<T1> stage1,
AggregateOperation1<? super T1,?,? extends R1> aggrOp1)
Attaches a stage that performs the given co-aggregate operations over
the items from this stage and
stage1 you supply. |
default <T1,R0,R1> StreamStage<KeyedWindowResult<K,Tuple2<R0,R1>>> |
StageWithKeyAndWindow.aggregate2(AggregateOperation1<? super T,?,? extends R0> aggrOp0,
StreamStageWithKey<T1,? extends K> stage1,
AggregateOperation1<? super T1,?,? extends R1> aggrOp1)
Attaches a stage that performs the given cogroup-and-aggregate operation
over the items from both this stage and
stage1 you supply. |
default <T1,R0,R1> StreamStage<KeyedWindowResult<K,Tuple2<R0,R1>>> |
StageWithKeyAndWindow.aggregate2(AggregateOperation1<? super T,?,? extends R0> aggrOp0,
StreamStageWithKey<T1,? extends K> stage1,
AggregateOperation1<? super T1,?,? extends R1> aggrOp1)
Attaches a stage that performs the given cogroup-and-aggregate operation
over the items from both this stage and
stage1 you supply. |
default <T1,T2,R0,R1,R2> |
BatchStage.aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0,
BatchStage<T1> stage1,
AggregateOperation1<? super T1,?,? extends R1> aggrOp1,
BatchStage<T2> stage2,
AggregateOperation1<? super T2,?,? extends R2> aggrOp2)
Attaches a stage that co-aggregates the data from this and the two
supplied stages by performing a separate aggregate operation on each and
emits a single
Tuple3 with their results. |
default <T1,T2,R0,R1,R2> |
BatchStage.aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0,
BatchStage<T1> stage1,
AggregateOperation1<? super T1,?,? extends R1> aggrOp1,
BatchStage<T2> stage2,
AggregateOperation1<? super T2,?,? extends R2> aggrOp2)
Attaches a stage that co-aggregates the data from this and the two
supplied stages by performing a separate aggregate operation on each and
emits a single
Tuple3 with their results. |
default <T1,T2,R0,R1,R2> |
BatchStage.aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0,
BatchStage<T1> stage1,
AggregateOperation1<? super T1,?,? extends R1> aggrOp1,
BatchStage<T2> stage2,
AggregateOperation1<? super T2,?,? extends R2> aggrOp2)
Attaches a stage that co-aggregates the data from this and the two
supplied stages by performing a separate aggregate operation on each and
emits a single
Tuple3 with their results. |
default <T1,T2,R0,R1,R2> |
BatchStageWithKey.aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0,
BatchStageWithKey<T1,? extends K> stage1,
AggregateOperation1<? super T1,?,? extends R1> aggrOp1,
BatchStageWithKey<T2,? extends K> stage2,
AggregateOperation1<? super T2,?,? extends R2> aggrOp2)
Attaches a stage that performs the given cogroup-and-aggregate
transformation of the items from this stage as well as
stage1
and stage2 you supply. |
default <T1,T2,R0,R1,R2> |
BatchStageWithKey.aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0,
BatchStageWithKey<T1,? extends K> stage1,
AggregateOperation1<? super T1,?,? extends R1> aggrOp1,
BatchStageWithKey<T2,? extends K> stage2,
AggregateOperation1<? super T2,?,? extends R2> aggrOp2)
Attaches a stage that performs the given cogroup-and-aggregate
transformation of the items from this stage as well as
stage1
and stage2 you supply. |
default <T1,T2,R0,R1,R2> |
BatchStageWithKey.aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0,
BatchStageWithKey<T1,? extends K> stage1,
AggregateOperation1<? super T1,?,? extends R1> aggrOp1,
BatchStageWithKey<T2,? extends K> stage2,
AggregateOperation1<? super T2,?,? extends R2> aggrOp2)
Attaches a stage that performs the given cogroup-and-aggregate
transformation of the items from this stage as well as
stage1
and stage2 you supply. |
default <T1,T2,R0,R1,R2> |
StageWithWindow.aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0,
StreamStage<T1> stage1,
AggregateOperation1<? super T1,?,? extends R1> aggrOp1,
StreamStage<T2> stage2,
AggregateOperation1<? super T2,?,? extends R2> aggrOp2)
Attaches a stage that performs the given aggregate operation over all
the items that belong to the same window.
|
default <T1,T2,R0,R1,R2> |
StageWithWindow.aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0,
StreamStage<T1> stage1,
AggregateOperation1<? super T1,?,? extends R1> aggrOp1,
StreamStage<T2> stage2,
AggregateOperation1<? super T2,?,? extends R2> aggrOp2)
Attaches a stage that performs the given aggregate operation over all
the items that belong to the same window.
|
default <T1,T2,R0,R1,R2> |
StageWithWindow.aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0,
StreamStage<T1> stage1,
AggregateOperation1<? super T1,?,? extends R1> aggrOp1,
StreamStage<T2> stage2,
AggregateOperation1<? super T2,?,? extends R2> aggrOp2)
Attaches a stage that performs the given aggregate operation over all
the items that belong to the same window.
|
default <T1,T2,R0,R1,R2> |
StageWithKeyAndWindow.aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0,
StreamStageWithKey<T1,? extends K> stage1,
AggregateOperation1<? super T1,?,? extends R1> aggrOp1,
StreamStageWithKey<T2,? extends K> stage2,
AggregateOperation1<? super T2,?,? extends R2> aggrOp2)
Attaches a stage that performs the given cogroup-and-aggregate operation
over the items from both this stage and
stage1 you supply. |
default <T1,T2,R0,R1,R2> |
StageWithKeyAndWindow.aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0,
StreamStageWithKey<T1,? extends K> stage1,
AggregateOperation1<? super T1,?,? extends R1> aggrOp1,
StreamStageWithKey<T2,? extends K> stage2,
AggregateOperation1<? super T2,?,? extends R2> aggrOp2)
Attaches a stage that performs the given cogroup-and-aggregate operation
over the items from both this stage and
stage1 you supply. |
default <T1,T2,R0,R1,R2> |
StageWithKeyAndWindow.aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0,
StreamStageWithKey<T1,? extends K> stage1,
AggregateOperation1<? super T1,?,? extends R1> aggrOp1,
StreamStageWithKey<T2,? extends K> stage2,
AggregateOperation1<? super T2,?,? extends R2> aggrOp2)
Attaches a stage that performs the given cogroup-and-aggregate operation
over the items from both this stage and
stage1 you supply. |
default <R0> WindowAggregateBuilder<R0> |
StageWithWindow.aggregateBuilder(AggregateOperation1<? super T,?,? extends R0> aggrOp)
Offers a step-by-step API to build a pipeline stage that co-aggregates
the data from several input stages.
|
default <R0> WindowGroupAggregateBuilder<K,R0> |
StageWithKeyAndWindow.aggregateBuilder(AggregateOperation1<? super T,?,? extends R0> aggrOp0)
Offers a step-by-step API to build a pipeline stage that co-aggregates
the data from several input stages.
|
default <R0> AggregateBuilder<R0> |
BatchStage.aggregateBuilder(AggregateOperation1<? super T,?,? extends R0> aggrOp0)
Offers a step-by-step API to build a pipeline stage that co-aggregates
the data from several input stages.
|
default <R0> GroupAggregateBuilder<K,R0> |
BatchStageWithKey.aggregateBuilder(AggregateOperation1<? super T,?,? extends R0> aggrOp0)
Offers a step-by-step API to build a pipeline stage that co-aggregates
the data from several input stages.
|
default <A,R> StreamStage<R> |
StreamStage.rollingAggregate(AggregateOperation1<? super T,A,? extends R> aggrOp) |
default <A,R> StreamStage<Map.Entry<K,R>> |
StreamStageWithKey.rollingAggregate(AggregateOperation1<? super T,A,? extends R> aggrOp) |
default <A,R> GeneralStage<Map.Entry<K,R>> |
GeneralStageWithKey.rollingAggregate(AggregateOperation1<? super T,A,? extends R> aggrOp)
Attaches a rolling aggregation stage.
|
default <A,R> GeneralStage<R> |
GeneralStage.rollingAggregate(AggregateOperation1<? super T,A,? extends R> aggrOp)
Attaches a rolling aggregation stage.
|
default <A,R> BatchStage<R> |
BatchStage.rollingAggregate(AggregateOperation1<? super T,A,? extends R> aggrOp) |
default <A,R> BatchStage<Map.Entry<K,R>> |
BatchStageWithKey.rollingAggregate(AggregateOperation1<? super T,A,? extends R> aggrOp) |
default <A,R> StreamStage<Map.Entry<K,R>> |
StreamStageWithKey.rollingAggregate(long ttl,
AggregateOperation1<? super T,A,? extends R> aggrOp)
Attaches a rolling aggregation stage.
|
Copyright © 2023 Hazelcast, Inc.. All rights reserved.