org.apache.flink.streaming.api.datastream

Class CoGroupedStreams.WithWindow<T1,T2,KEY,W extends Window>

java.lang.Object

org.apache.flink.streaming.api.datastream.CoGroupedStreams.WithWindow<T1,T2,KEY,W>

Type Parameters:

T1 - Type of the elements from the first input

T2 - Type of the elements from the second input

KEY - Type of the key. This must be the same for both inputs

W - Type of Window on which the co-group operation works.

Enclosing class:

CoGroupedStreams<T1,T2>

@Public
public static class CoGroupedStreams.WithWindow<T1,T2,KEY,W extends Window>
extends Object

A co-group operation that has KeySelectors defined for both inputs as well as a WindowAssigner.

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	WithWindow(DataStream<T1> input1, DataStream<T2> input2, KeySelector<T1,KEY> keySelector1, KeySelector<T2,KEY> keySelector2, TypeInformation<KEY> keyType, WindowAssigner<? super CoGroupedStreams.TaggedUnion<T1,T2>,W> windowAssigner, Trigger<? super CoGroupedStreams.TaggedUnion<T1,T2>,? super W> trigger, Evictor<? super CoGroupedStreams.TaggedUnion<T1,T2>,? super W> evictor, Duration allowedLateness)
protected	WithWindow(DataStream<T1> input1, DataStream<T2> input2, KeySelector<T1,KEY> keySelector1, KeySelector<T2,KEY> keySelector2, TypeInformation<KEY> keyType, WindowAssigner<? super CoGroupedStreams.TaggedUnion<T1,T2>,W> windowAssigner, Trigger<? super CoGroupedStreams.TaggedUnion<T1,T2>,? super W> trigger, Evictor<? super CoGroupedStreams.TaggedUnion<T1,T2>,? super W> evictor, Time allowedLateness) Deprecated. Use WithWindow(DataStream, DataStream, KeySelector, KeySelector, TypeInformation, WindowAssigner, Trigger, Evictor, Duration)

Method Summary

Modifier and Type	Method and Description
CoGroupedStreams.WithWindow<T1,T2,KEY,W>	allowedLateness(Duration newLateness) Sets the time by which elements are allowed to be late.
CoGroupedStreams.WithWindow<T1,T2,KEY,W>	allowedLateness(Time newLateness) Deprecated. Use allowedLateness(Duration)
<T> DataStream<T>	apply(CoGroupFunction<T1,T2,T> function) Completes the co-group operation with the user function that is executed for windowed groups.
<T> DataStream<T>	apply(CoGroupFunction<T1,T2,T> function, TypeInformation<T> resultType) Completes the co-group operation with the user function that is executed for windowed groups.
CoGroupedStreams.WithWindow<T1,T2,KEY,W>	evictor(Evictor<? super CoGroupedStreams.TaggedUnion<T1,T2>,? super W> newEvictor) Sets the Evictor that should be used to evict elements from a window before emission.
CoGroupedStreams.WithWindow<T1,T2,KEY,W>	trigger(Trigger<? super CoGroupedStreams.TaggedUnion<T1,T2>,? super W> newTrigger) Sets the Trigger that should be used to trigger window emission.
<T> SingleOutputStreamOperator<T>	with(CoGroupFunction<T1,T2,T> function) Deprecated. This method will be removed once the apply(CoGroupFunction) method is fixed in the next major version of Flink (2.0).
<T> SingleOutputStreamOperator<T>	with(CoGroupFunction<T1,T2,T> function, TypeInformation<T> resultType) Deprecated. This method will be removed once the apply(CoGroupFunction, TypeInformation) method is fixed in the next major version of Flink (2.0).

Methods inherited from class java.lang.Object

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

Constructor Detail

WithWindow

@Deprecated
protected WithWindow(DataStream<T1> input1,
                                 DataStream<T2> input2,
                                 KeySelector<T1,KEY> keySelector1,
                                 KeySelector<T2,KEY> keySelector2,
                                 TypeInformation<KEY> keyType,
                                 WindowAssigner<? super CoGroupedStreams.TaggedUnion<T1,T2>,W> windowAssigner,
                                 Trigger<? super CoGroupedStreams.TaggedUnion<T1,T2>,? super W> trigger,
                                 Evictor<? super CoGroupedStreams.TaggedUnion<T1,T2>,? super W> evictor,
                                 @Nullable
                                 Time allowedLateness)

Deprecated. Use WithWindow(DataStream, DataStream, KeySelector, KeySelector, TypeInformation, WindowAssigner, Trigger, Evictor, Duration)

WithWindow

protected WithWindow(DataStream<T1> input1,
                     DataStream<T2> input2,
                     KeySelector<T1,KEY> keySelector1,
                     KeySelector<T2,KEY> keySelector2,
                     TypeInformation<KEY> keyType,
                     WindowAssigner<? super CoGroupedStreams.TaggedUnion<T1,T2>,W> windowAssigner,
                     Trigger<? super CoGroupedStreams.TaggedUnion<T1,T2>,? super W> trigger,
                     Evictor<? super CoGroupedStreams.TaggedUnion<T1,T2>,? super W> evictor,
                     @Nullable
                     Duration allowedLateness)

Method Detail

trigger

@PublicEvolving
public CoGroupedStreams.WithWindow<T1,T2,KEY,W> trigger(Trigger<? super CoGroupedStreams.TaggedUnion<T1,T2>,? super W> newTrigger)

Sets the Trigger that should be used to trigger window emission.

evictor

@PublicEvolving
public CoGroupedStreams.WithWindow<T1,T2,KEY,W> evictor(Evictor<? super CoGroupedStreams.TaggedUnion<T1,T2>,? super W> newEvictor)

Sets the Evictor that should be used to evict elements from a window before emission.

Note: When using an evictor window performance will degrade significantly, since pre-aggregation of window results cannot be used.

allowedLateness

@Deprecated
 @PublicEvolving
public CoGroupedStreams.WithWindow<T1,T2,KEY,W> allowedLateness(@Nullable
                                                                                             Time newLateness)

Deprecated. Use allowedLateness(Duration)

Sets the time by which elements are allowed to be late.

See Also:

WindowedStream.allowedLateness(Time)

allowedLateness

@PublicEvolving
public CoGroupedStreams.WithWindow<T1,T2,KEY,W> allowedLateness(@Nullable
                                                                                Duration newLateness)

Sets the time by which elements are allowed to be late.

See Also:

WindowedStream.allowedLateness(Duration)

apply

public <T> DataStream<T> apply(CoGroupFunction<T1,T2,T> function)

Completes the co-group operation with the user function that is executed for windowed groups.

Note: This method's return type does not support setting an operator-specific parallelism. Due to binary backwards compatibility, this cannot be altered. Use the with(CoGroupFunction) method to set an operator-specific parallelism.

with

@PublicEvolving
 @Deprecated
public <T> SingleOutputStreamOperator<T> with(CoGroupFunction<T1,T2,T> function)

Deprecated. This method will be removed once the apply(CoGroupFunction) method is fixed in the next major version of Flink (2.0).

Completes the co-group operation with the user function that is executed for windowed groups.

Note: This is a temporary workaround while the apply(CoGroupFunction) method has the wrong return type and hence does not allow one to set an operator-specific parallelism

apply

public <T> DataStream<T> apply(CoGroupFunction<T1,T2,T> function,
                               TypeInformation<T> resultType)

Completes the co-group operation with the user function that is executed for windowed groups.

Note: This method's return type does not support setting an operator-specific parallelism. Due to binary backwards compatibility, this cannot be altered. Use the with(CoGroupFunction, TypeInformation) method to set an operator-specific parallelism.

with

@PublicEvolving
 @Deprecated
public <T> SingleOutputStreamOperator<T> with(CoGroupFunction<T1,T2,T> function,
                                                                           TypeInformation<T> resultType)

Deprecated. This method will be removed once the apply(CoGroupFunction, TypeInformation) method is fixed in the next major version of Flink (2.0).

Completes the co-group operation with the user function that is executed for windowed groups.

Note: This is a temporary workaround while the apply(CoGroupFunction, TypeInformation) method has the wrong return type and hence does not allow one to set an operator-specific parallelism