T1
- Type of the elements from the first inputT2
- Type of the elements from the second inputKEY
- Type of the key. This must be the same for both inputsW
- Type of Window
on which the join operation works.@Public public static class JoinedStreams.WithWindow<T1,T2,KEY,W extends Window> extends Object
KeySelectors
defined for both inputs as well as
a WindowAssigner
.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)
|
Modifier and Type | Method and Description |
---|---|
JoinedStreams.WithWindow<T1,T2,KEY,W> |
allowedLateness(Duration newLateness)
Sets the time by which elements are allowed to be late.
|
JoinedStreams.WithWindow<T1,T2,KEY,W> |
allowedLateness(Time newLateness)
Deprecated.
|
<T> DataStream<T> |
apply(FlatJoinFunction<T1,T2,T> function)
Completes the join operation with the user function that is executed for each combination
of elements with the same key in a window.
|
<T> DataStream<T> |
apply(FlatJoinFunction<T1,T2,T> function,
TypeInformation<T> resultType)
Completes the join operation with the user function that is executed for each combination
of elements with the same key in a window.
|
<T> DataStream<T> |
apply(JoinFunction<T1,T2,T> function)
Completes the join operation with the user function that is executed for each combination
of elements with the same key in a window.
|
<T> DataStream<T> |
apply(JoinFunction<T1,T2,T> function,
TypeInformation<T> resultType)
Completes the join operation with the user function that is executed for each combination
of elements with the same key in a window.
|
JoinedStreams.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. |
JoinedStreams.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(FlatJoinFunction<T1,T2,T> function)
Deprecated.
This method will be removed once the
apply(FlatJoinFunction) method
is fixed in the next major version of Flink (2.0). |
<T> SingleOutputStreamOperator<T> |
with(FlatJoinFunction<T1,T2,T> function,
TypeInformation<T> resultType)
Deprecated.
This method will be replaced by
apply(FlatJoinFunction,
TypeInformation) in Flink 2.0. So use the apply(FlatJoinFunction,
TypeInformation) in the future. |
<T> SingleOutputStreamOperator<T> |
with(JoinFunction<T1,T2,T> function)
Deprecated.
This method will be removed once the
apply(JoinFunction) method is
fixed in the next major version of Flink (2.0). |
<T> SingleOutputStreamOperator<T> |
with(JoinFunction<T1,T2,T> function,
TypeInformation<T> resultType)
Deprecated.
This method will be removed once the
apply(JoinFunction,
TypeInformation) method is fixed in the next major version of Flink (2.0). |
@Deprecated @PublicEvolving 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)
@PublicEvolving 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)
@PublicEvolving public JoinedStreams.WithWindow<T1,T2,KEY,W> trigger(Trigger<? super CoGroupedStreams.TaggedUnion<T1,T2>,? super W> newTrigger)
Trigger
that should be used to trigger window emission.@PublicEvolving public JoinedStreams.WithWindow<T1,T2,KEY,W> evictor(Evictor<? super CoGroupedStreams.TaggedUnion<T1,T2>,? super W> newEvictor)
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.
@Deprecated @PublicEvolving public JoinedStreams.WithWindow<T1,T2,KEY,W> allowedLateness(@Nullable Time newLateness)
allowedLateness(Duration)
.WindowedStream.allowedLateness(Duration)
@PublicEvolving public JoinedStreams.WithWindow<T1,T2,KEY,W> allowedLateness(@Nullable Duration newLateness)
WindowedStream.allowedLateness(Duration)
public <T> DataStream<T> apply(JoinFunction<T1,T2,T> function)
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(JoinFunction)
method to set an operator-specific parallelism.
@PublicEvolving @Deprecated public <T> SingleOutputStreamOperator<T> with(JoinFunction<T1,T2,T> function)
apply(JoinFunction)
method is
fixed in the next major version of Flink (2.0).Note: This is a temporary workaround while the apply(JoinFunction)
method has the wrong return type and hence does not allow one to set an operator-specific
parallelism
public <T> DataStream<T> apply(FlatJoinFunction<T1,T2,T> function, TypeInformation<T> resultType)
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(JoinFunction, TypeInformation)
, method to set an operator-specific
parallelism.
@PublicEvolving @Deprecated public <T> SingleOutputStreamOperator<T> with(FlatJoinFunction<T1,T2,T> function, TypeInformation<T> resultType)
apply(FlatJoinFunction,
TypeInformation)
in Flink 2.0. So use the apply(FlatJoinFunction,
TypeInformation)
in the future.Note: This is a temporary workaround while the apply(JoinFunction,
TypeInformation)
method has the wrong return type and hence does not allow one to set an
operator-specific parallelism
public <T> DataStream<T> apply(FlatJoinFunction<T1,T2,T> function)
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(FlatJoinFunction)
, method to set an operator-specific parallelism.
@PublicEvolving @Deprecated public <T> SingleOutputStreamOperator<T> with(FlatJoinFunction<T1,T2,T> function)
apply(FlatJoinFunction)
method
is fixed in the next major version of Flink (2.0).Note: This is a temporary workaround while the apply(FlatJoinFunction)
method has the wrong return type and hence does not allow one to set an operator-specific
parallelism.
public <T> DataStream<T> apply(JoinFunction<T1,T2,T> function, TypeInformation<T> resultType)
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(JoinFunction, TypeInformation)
, method to set an operator-specific
parallelism.
@PublicEvolving @Deprecated public <T> SingleOutputStreamOperator<T> with(JoinFunction<T1,T2,T> function, TypeInformation<T> resultType)
apply(JoinFunction,
TypeInformation)
method is fixed in the next major version of Flink (2.0).Note: This is a temporary workaround while the apply(FlatJoinFunction,
TypeInformation)
method has the wrong return type and hence does not allow one to set an
operator-specific parallelism
Copyright © 2014–2024 The Apache Software Foundation. All rights reserved.