Modifier and Type | Method and Description |
---|---|
<R> DataStream<R> |
PatternStream.flatSelect(scala.Function2<scala.collection.mutable.Map<String,T>,Collector<R>,scala.runtime.BoxedUnit> patternFlatSelectFun,
TypeInformation<R> evidence$10)
Applies a flat select function to the detected pattern sequence.
|
<L,R> DataStream<scala.util.Either<L,R>> |
PatternStream.flatSelect(scala.Function3<scala.collection.mutable.Map<String,T>,Object,Collector<L>,scala.runtime.BoxedUnit> patternFlatTimeoutFunction,
scala.Function2<scala.collection.mutable.Map<String,T>,Collector<R>,scala.runtime.BoxedUnit> patternFlatSelectFunction,
TypeInformation<L> evidence$11,
TypeInformation<R> evidence$12)
Applies a flat select function to the detected pattern sequence.
|
<R> DataStream<R> |
PatternStream.flatSelect(PatternFlatSelectFunction<T,R> patternFlatSelectFunction,
TypeInformation<R> evidence$4)
Applies a flat select function to the detected pattern sequence.
|
<L,R> DataStream<scala.util.Either<L,R>> |
PatternStream.flatSelect(PatternFlatTimeoutFunction<T,L> patternFlatTimeoutFunction,
PatternFlatSelectFunction<T,R> patternFlatSelectFunction,
TypeInformation<L> evidence$5,
TypeInformation<R> evidence$6)
Applies a flat select function to the detected pattern sequence.
|
DataStream<T> |
PatternStream.getInputStream() |
<R> DataStream<R> |
PatternStream.select(scala.Function1<scala.collection.mutable.Map<String,T>,R> patternSelectFun,
TypeInformation<R> evidence$7)
Applies a select function to the detected pattern sequence.
|
<L,R> DataStream<scala.util.Either<L,R>> |
PatternStream.select(scala.Function2<scala.collection.mutable.Map<String,T>,Object,L> patternTimeoutFunction,
scala.Function1<scala.collection.mutable.Map<String,T>,R> patternSelectFunction,
TypeInformation<L> evidence$8,
TypeInformation<R> evidence$9)
Applies a select function to the detected pattern sequence.
|
<R> DataStream<R> |
PatternStream.select(PatternSelectFunction<T,R> patternSelectFunction,
TypeInformation<R> evidence$1)
Applies a select function to the detected pattern sequence.
|
<L,R> DataStream<scala.util.Either<L,R>> |
PatternStream.select(PatternTimeoutFunction<T,L> patternTimeoutFunction,
PatternSelectFunction<T,R> patternSelectFunction,
TypeInformation<L> evidence$2,
TypeInformation<R> evidence$3)
Applies a select function to the detected pattern sequence.
|
Modifier and Type | Method and Description |
---|---|
<T> PatternStream<T> |
CEP$.pattern(DataStream<T> input,
Pattern<T,?> pattern)
Transforms a
DataStream into a PatternStream in the Scala API. |
static <T> PatternStream<T> |
CEP.pattern(DataStream<T> input,
Pattern<T,?> pattern)
Transforms a
DataStream into a PatternStream in the Scala API. |
Modifier and Type | Class and Description |
---|---|
class |
KeyedStream<T,K> |
class |
SplitStream<T>
The SplitStream represents an operator that has been split using an
OutputSelector . |
Modifier and Type | Method and Description |
---|---|
<T> DataStream<T> |
StreamExecutionEnvironment.addSource(scala.Function1<SourceFunction.SourceContext<T>,scala.runtime.BoxedUnit> function,
TypeInformation<T> evidence$10)
Create a DataStream using a user defined source function for arbitrary
source functionality.
|
<T> DataStream<T> |
StreamExecutionEnvironment.addSource(SourceFunction<T> function,
TypeInformation<T> evidence$9)
Create a DataStream using a user defined source function for arbitrary
source functionality.
|
DataStream<T> |
AllWindowedStream.aggregate(AggregationFunction.AggregationType aggregationType,
int position) |
DataStream<T> |
WindowedStream.aggregate(AggregationFunction.AggregationType aggregationType,
int position) |
<R> DataStream<R> |
AllWindowedStream.apply(AllWindowFunction<T,R,W> function,
TypeInformation<R> evidence$9)
Applies the given window function to each window.
|
<T> DataStream<T> |
CoGroupedStreams.Where.EqualTo.WithWindow.apply(CoGroupFunction<T1,T2,T> function,
TypeInformation<T> evidence$4)
Completes the co-group operation with the user function that is executed
for windowed groups.
|
<T> DataStream<T> |
JoinedStreams.Where.EqualTo.WithWindow.apply(FlatJoinFunction<T1,T2,T> function,
TypeInformation<T> evidence$5)
Completes the join operation with the user function that is executed
for windowed groups.
|
<O> DataStream<O> |
CoGroupedStreams.Where.EqualTo.WithWindow.apply(scala.Function2<scala.collection.Iterator<T1>,scala.collection.Iterator<T2>,O> fun,
TypeInformation<O> evidence$2)
Completes the co-group operation with the user function that is executed
for windowed groups.
|
<O> DataStream<O> |
JoinedStreams.Where.EqualTo.WithWindow.apply(scala.Function2<T1,T2,O> fun,
TypeInformation<O> evidence$2)
Completes the join operation with the user function that is executed
for windowed groups.
|
<R> DataStream<R> |
AllWindowedStream.apply(scala.Function2<T,T,T> preAggregator,
scala.Function3<W,scala.collection.Iterable<T>,Collector<R>,scala.runtime.BoxedUnit> windowFunction,
TypeInformation<R> evidence$12)
Deprecated.
Use
reduce(ReduceFunction, AllWindowFunction) instead. |
<R> DataStream<R> |
WindowedStream.apply(scala.Function2<T,T,T> preAggregator,
scala.Function4<K,W,scala.collection.Iterable<T>,Collector<R>,scala.runtime.BoxedUnit> windowFunction,
TypeInformation<R> evidence$12)
Deprecated.
Use
reduce(ReduceFunction, WindowFunction) instead. |
<O> DataStream<O> |
CoGroupedStreams.Where.EqualTo.WithWindow.apply(scala.Function3<scala.collection.Iterator<T1>,scala.collection.Iterator<T2>,Collector<O>,scala.runtime.BoxedUnit> fun,
TypeInformation<O> evidence$3)
Completes the co-group operation with the user function that is executed
for windowed groups.
|
<O> DataStream<O> |
JoinedStreams.Where.EqualTo.WithWindow.apply(scala.Function3<T1,T2,Collector<O>,scala.runtime.BoxedUnit> fun,
TypeInformation<O> evidence$3)
Completes the join operation with the user function that is executed
for windowed groups.
|
<R> DataStream<R> |
AllWindowedStream.apply(scala.Function3<W,scala.collection.Iterable<T>,Collector<R>,scala.runtime.BoxedUnit> function,
TypeInformation<R> evidence$10)
Applies the given window function to each window.
|
<R> DataStream<R> |
WindowedStream.apply(scala.Function4<K,W,scala.collection.Iterable<T>,Collector<R>,scala.runtime.BoxedUnit> function,
TypeInformation<R> evidence$10)
Applies the given window function to each window.
|
<T> DataStream<T> |
JoinedStreams.Where.EqualTo.WithWindow.apply(JoinFunction<T1,T2,T> function,
TypeInformation<T> evidence$4)
Completes the join operation with the user function that is executed
for windowed groups.
|
<R> DataStream<R> |
AllWindowedStream.apply(ReduceFunction<T> preAggregator,
AllWindowFunction<T,R,W> windowFunction,
TypeInformation<R> evidence$11)
Deprecated.
Use
reduce(ReduceFunction, AllWindowFunction) instead. |
<R> DataStream<R> |
WindowedStream.apply(ReduceFunction<T> preAggregator,
WindowFunction<T,R,K,W> function,
TypeInformation<R> evidence$11)
Deprecated.
Use
reduce(ReduceFunction, WindowFunction) instead. |
<R> DataStream<R> |
AllWindowedStream.apply(R initialValue,
FoldFunction<T,R> preAggregator,
AllWindowFunction<R,R,W> windowFunction,
TypeInformation<R> evidence$13)
Deprecated.
Use
fold(R, FoldFunction, AllWindowFunction) instead. |
<R> DataStream<R> |
WindowedStream.apply(R initialValue,
FoldFunction<T,R> foldFunction,
WindowFunction<R,R,K,W> function,
TypeInformation<R> evidence$13)
Deprecated.
Use
fold(R, FoldFunction, WindowFunction) instead. |
<R> DataStream<R> |
AllWindowedStream.apply(R initialValue,
scala.Function2<R,T,R> preAggregator,
scala.Function3<W,scala.collection.Iterable<R>,Collector<R>,scala.runtime.BoxedUnit> windowFunction,
TypeInformation<R> evidence$14)
Deprecated.
Use
fold(R, FoldFunction, AllWindowFunction instead. |
<R> DataStream<R> |
WindowedStream.apply(R initialValue,
scala.Function2<R,T,R> foldFunction,
scala.Function4<K,W,scala.collection.Iterable<R>,Collector<R>,scala.runtime.BoxedUnit> windowFunction,
TypeInformation<R> evidence$14)
Deprecated.
Use
fold(R, FoldFunction, WindowFunction) instead. |
<R> DataStream<R> |
WindowedStream.apply(WindowFunction<T,R,K,W> function,
TypeInformation<R> evidence$9)
Applies the given window function to each window.
|
DataStream<T> |
DataStream.assignAscendingTimestamps(scala.Function1<T,Object> extractor)
Assigns timestamps to the elements in the data stream and periodically creates
watermarks to signal event time progress.
|
DataStream<T> |
DataStream.assignTimestamps(TimestampExtractor<T> extractor)
Extracts a timestamp from an element and assigns it as the internal timestamp of that element.
|
DataStream<T> |
DataStream.assignTimestampsAndWatermarks(AssignerWithPeriodicWatermarks<T> assigner)
Assigns timestamps to the elements in the data stream and periodically creates
watermarks to signal event time progress.
|
DataStream<T> |
DataStream.assignTimestampsAndWatermarks(AssignerWithPunctuatedWatermarks<T> assigner)
Assigns timestamps to the elements in the data stream and periodically creates
watermarks to signal event time progress.
|
DataStream<T> |
DataStream.broadcast()
Sets the partitioning of the DataStream so that the output tuples
are broad casted to every parallel instance of the next component.
|
<T> DataStream<T> |
StreamExecutionEnvironment.createInput(InputFormat<T,?> inputFormat,
TypeInformation<T> evidence$8)
Generic method to create an input data stream with a specific input format.
|
DataStream<T> |
DataStream.disableChaining()
Turns off chaining for this operator so thread co-location will not be
used as an optimization.
|
DataStream<T> |
DataStream.filter(FilterFunction<T> filter)
Creates a new DataStream that contains only the elements satisfying the given filter predicate.
|
DataStream<T> |
DataStream.filter(scala.Function1<T,Object> fun)
Creates a new DataStream that contains only the elements satisfying the given filter predicate.
|
<S> DataStream<T> |
KeyedStream.filterWithState(scala.Function2<T,scala.Option<S>,scala.Tuple2<Object,scala.Option<S>>> fun,
TypeInformation<S> evidence$4)
Creates a new DataStream that contains only the elements satisfying the given stateful filter
predicate.
|
<R> DataStream<R> |
ConnectedStreams.flatMap(CoFlatMapFunction<IN1,IN2,R> coFlatMapper,
TypeInformation<R> evidence$4)
Applies a CoFlatMap transformation on these connected streams.
|
<R> DataStream<R> |
DataStream.flatMap(FlatMapFunction<T,R> flatMapper,
TypeInformation<R> evidence$8)
Creates a new DataStream by applying the given function to every element and flattening
the results.
|
<R> DataStream<R> |
ConnectedStreams.flatMap(scala.Function1<IN1,scala.collection.TraversableOnce<R>> fun1,
scala.Function1<IN2,scala.collection.TraversableOnce<R>> fun2,
TypeInformation<R> evidence$6)
Applies a CoFlatMap transformation on the connected streams.
|
<R> DataStream<R> |
DataStream.flatMap(scala.Function1<T,scala.collection.TraversableOnce<R>> fun,
TypeInformation<R> evidence$10)
Creates a new DataStream by applying the given function to every element and flattening
the results.
|
<R> DataStream<R> |
ConnectedStreams.flatMap(scala.Function2<IN1,Collector<R>,scala.runtime.BoxedUnit> fun1,
scala.Function2<IN2,Collector<R>,scala.runtime.BoxedUnit> fun2,
TypeInformation<R> evidence$5)
Applies a CoFlatMap transformation on the connected streams.
|
<R> DataStream<R> |
DataStream.flatMap(scala.Function2<T,Collector<R>,scala.runtime.BoxedUnit> fun,
TypeInformation<R> evidence$9)
Creates a new DataStream by applying the given function to every element and flattening
the results.
|
<R,S> DataStream<R> |
KeyedStream.flatMapWithState(scala.Function2<T,scala.Option<S>,scala.Tuple2<scala.collection.TraversableOnce<R>,scala.Option<S>>> fun,
TypeInformation<R> evidence$7,
TypeInformation<S> evidence$8)
Creates a new DataStream by applying the given stateful function to every element and
flattening the results.
|
<ACC,R> DataStream<R> |
AllWindowedStream.fold(ACC initialValue,
FoldFunction<T,ACC> preAggregator,
AllWindowFunction<ACC,R,W> windowFunction,
TypeInformation<ACC> evidence$5,
TypeInformation<R> evidence$6)
Applies the given window function to each window.
|
<ACC,R> DataStream<R> |
WindowedStream.fold(ACC initialValue,
FoldFunction<T,ACC> foldFunction,
WindowFunction<ACC,R,K,W> function,
TypeInformation<ACC> evidence$5,
TypeInformation<R> evidence$6)
Applies the given window function to each window.
|
<ACC,R> DataStream<R> |
AllWindowedStream.fold(ACC initialValue,
scala.Function2<ACC,T,ACC> preAggregator,
scala.Function3<W,scala.collection.Iterable<ACC>,Collector<R>,scala.runtime.BoxedUnit> windowFunction,
TypeInformation<ACC> evidence$7,
TypeInformation<R> evidence$8)
Applies the given window function to each window.
|
<ACC,R> DataStream<R> |
WindowedStream.fold(ACC initialValue,
scala.Function2<ACC,T,ACC> foldFunction,
scala.Function4<K,W,scala.collection.Iterable<ACC>,Collector<R>,scala.runtime.BoxedUnit> windowFunction,
TypeInformation<ACC> evidence$7,
TypeInformation<R> evidence$8)
Applies the given window function to each window.
|
<R> DataStream<R> |
KeyedStream.fold(R initialValue,
FoldFunction<T,R> folder,
TypeInformation<R> evidence$2)
Creates a new
DataStream by folding the elements of this DataStream
using an associative fold function and an initial value. |
<R> DataStream<R> |
AllWindowedStream.fold(R initialValue,
FoldFunction<T,R> function,
TypeInformation<R> evidence$3)
Applies the given fold function to each window.
|
<R> DataStream<R> |
WindowedStream.fold(R initialValue,
FoldFunction<T,R> function,
TypeInformation<R> evidence$3)
Applies the given fold function to each window.
|
<R> DataStream<R> |
KeyedStream.fold(R initialValue,
scala.Function2<R,T,R> fun,
TypeInformation<R> evidence$3)
Creates a new
DataStream by folding the elements of this DataStream
using an associative fold function and an initial value. |
<R> DataStream<R> |
AllWindowedStream.fold(R initialValue,
scala.Function2<R,T,R> function,
TypeInformation<R> evidence$4)
Applies the given fold function to each window.
|
<R> DataStream<R> |
WindowedStream.fold(R initialValue,
scala.Function2<R,T,R> function,
TypeInformation<R> evidence$4)
Applies the given fold function to each window.
|
DataStream<T> |
DataStream.forward()
Sets the partitioning of the DataStream so that the output tuples
are forwarded to the local subtask of the next component (whenever
possible).
|
<T> DataStream<T> |
StreamExecutionEnvironment.fromCollection(scala.collection.Iterator<T> data,
TypeInformation<T> evidence$3)
Creates a DataStream from the given
Iterator . |
<T> DataStream<T> |
StreamExecutionEnvironment.fromCollection(scala.collection.Seq<T> data,
TypeInformation<T> evidence$2)
Creates a DataStream from the given non-empty
Seq . |
<T> DataStream<T> |
StreamExecutionEnvironment.fromElements(scala.collection.Seq<T> data,
TypeInformation<T> evidence$1)
Creates a DataStream that contains the given elements.
|
<T> DataStream<T> |
StreamExecutionEnvironment.fromParallelCollection(SplittableIterator<T> data,
TypeInformation<T> evidence$4)
Creates a DataStream from the given
SplittableIterator . |
DataStream<Object> |
StreamExecutionEnvironment.generateSequence(long from,
long to)
Creates a new DataStream that contains a sequence of numbers.
|
DataStream<T> |
DataStream.global()
Sets the partitioning of the DataStream so that the output values all go to
the first instance of the next processing operator.
|
<R,F> DataStream<R> |
DataStream.iterate(scala.Function1<ConnectedStreams<T,F>,scala.Tuple2<DataStream<F>,DataStream<R>>> stepFunction,
long maxWaitTimeMillis,
TypeInformation<F> evidence$5)
Initiates an iterative part of the program that creates a loop by feeding
back data streams.
|
<R> DataStream<R> |
DataStream.iterate(scala.Function1<DataStream<T>,scala.Tuple2<DataStream<T>,DataStream<R>>> stepFunction,
long maxWaitTimeMillis,
boolean keepPartitioning)
Initiates an iterative part of the program that creates a loop by feeding
back data streams.
|
<R> DataStream<R> |
ConnectedStreams.map(CoMapFunction<IN1,IN2,R> coMapper,
TypeInformation<R> evidence$2)
Applies a CoMap transformation on these connected streams.
|
<R> DataStream<R> |
ConnectedStreams.map(scala.Function1<IN1,R> fun1,
scala.Function1<IN2,R> fun2,
TypeInformation<R> evidence$1)
Applies a CoMap transformation on the connected streams.
|
<R> DataStream<R> |
DataStream.map(scala.Function1<T,R> fun,
TypeInformation<R> evidence$6)
Creates a new DataStream by applying the given function to every element of this DataStream.
|
<R> DataStream<R> |
DataStream.map(MapFunction<T,R> mapper,
TypeInformation<R> evidence$7)
Creates a new DataStream by applying the given function to every element of this DataStream.
|
<R,S> DataStream<R> |
KeyedStream.mapWithState(scala.Function2<T,scala.Option<S>,scala.Tuple2<R,scala.Option<S>>> fun,
TypeInformation<R> evidence$5,
TypeInformation<S> evidence$6)
Creates a new DataStream by applying the given stateful function to every element of this
DataStream.
|
DataStream<T> |
KeyedStream.max(int position)
Applies an aggregation that that gives the current maximum of the data stream at
the given position by the given key.
|
DataStream<T> |
AllWindowedStream.max(int position)
Applies an aggregation that that gives the maximum of the elements in the window at
the given position.
|
DataStream<T> |
WindowedStream.max(int position)
Applies an aggregation that that gives the maximum of the elements in the window at
the given position.
|
DataStream<T> |
KeyedStream.max(String field)
Applies an aggregation that that gives the current maximum of the data stream at
the given field by the given key.
|
DataStream<T> |
AllWindowedStream.max(String field)
Applies an aggregation that that gives the maximum of the elements in the window at
the given field.
|
DataStream<T> |
WindowedStream.max(String field)
Applies an aggregation that that gives the maximum of the elements in the window at
the given field.
|
DataStream<T> |
KeyedStream.maxBy(int position)
Applies an aggregation that that gives the current maximum element of the data stream by
the given position by the given key.
|
DataStream<T> |
AllWindowedStream.maxBy(int position)
Applies an aggregation that that gives the maximum element of the window by
the given position.
|
DataStream<T> |
WindowedStream.maxBy(int position)
Applies an aggregation that that gives the maximum element of the window by
the given position.
|
DataStream<T> |
KeyedStream.maxBy(String field)
Applies an aggregation that that gives the current maximum element of the data stream by
the given field by the given key.
|
DataStream<T> |
AllWindowedStream.maxBy(String field)
Applies an aggregation that that gives the maximum element of the window by
the given field.
|
DataStream<T> |
WindowedStream.maxBy(String field)
Applies an aggregation that that gives the maximum element of the window by
the given field.
|
DataStream<T> |
KeyedStream.min(int position)
Applies an aggregation that that gives the current minimum of the data stream at
the given position by the given key.
|
DataStream<T> |
AllWindowedStream.min(int position)
Applies an aggregation that that gives the minimum of the elements in the window at
the given position.
|
DataStream<T> |
WindowedStream.min(int position)
Applies an aggregation that that gives the minimum of the elements in the window at
the given position.
|
DataStream<T> |
KeyedStream.min(String field)
Applies an aggregation that that gives the current minimum of the data stream at
the given field by the given key.
|
DataStream<T> |
AllWindowedStream.min(String field)
Applies an aggregation that that gives the minimum of the elements in the window at
the given field.
|
DataStream<T> |
WindowedStream.min(String field)
Applies an aggregation that that gives the minimum of the elements in the window at
the given field.
|
DataStream<T> |
KeyedStream.minBy(int position)
Applies an aggregation that that gives the current minimum element of the data stream by
the given position by the given key.
|
DataStream<T> |
AllWindowedStream.minBy(int position)
Applies an aggregation that that gives the minimum element of the window by
the given position.
|
DataStream<T> |
WindowedStream.minBy(int position)
Applies an aggregation that that gives the minimum element of the window by
the given position.
|
DataStream<T> |
KeyedStream.minBy(String field)
Applies an aggregation that that gives the current minimum element of the data stream by
the given field by the given key.
|
DataStream<T> |
AllWindowedStream.minBy(String field)
Applies an aggregation that that gives the minimum element of the window by
the given field.
|
DataStream<T> |
WindowedStream.minBy(String field)
Applies an aggregation that that gives the minimum element of the window by
the given field.
|
DataStream<T> |
DataStream.name(String name)
Sets the name of the current data stream.
|
<IN,OUT> DataStream<OUT> |
AsyncDataStream$.orderedWait(DataStream<IN> input,
AsyncFunction<IN,OUT> asyncFunction,
long timeout,
TimeUnit timeUnit,
int capacity,
TypeInformation<OUT> evidence$5)
Apply an asynchronous function on the input data stream.
|
static <IN,OUT> DataStream<OUT> |
AsyncDataStream.orderedWait(DataStream<IN> input,
AsyncFunction<IN,OUT> asyncFunction,
long timeout,
TimeUnit timeUnit,
int capacity,
TypeInformation<OUT> evidence$5)
Apply an asynchronous function on the input data stream.
|
<IN,OUT> DataStream<OUT> |
AsyncDataStream$.orderedWait(DataStream<IN> input,
AsyncFunction<IN,OUT> asyncFunction,
long timeout,
TimeUnit timeUnit,
TypeInformation<OUT> evidence$6)
Apply an asynchronous function on the input data stream.
|
static <IN,OUT> DataStream<OUT> |
AsyncDataStream.orderedWait(DataStream<IN> input,
AsyncFunction<IN,OUT> asyncFunction,
long timeout,
TimeUnit timeUnit,
TypeInformation<OUT> evidence$6)
Apply an asynchronous function on the input data stream.
|
<IN,OUT> DataStream<OUT> |
AsyncDataStream$.orderedWait(DataStream<IN> input,
long timeout,
TimeUnit timeUnit,
scala.Function2<IN,AsyncCollector<OUT>,scala.runtime.BoxedUnit> asyncFunction,
TypeInformation<OUT> evidence$8)
Apply an asynchronous function on the input data stream.
|
static <IN,OUT> DataStream<OUT> |
AsyncDataStream.orderedWait(DataStream<IN> input,
long timeout,
TimeUnit timeUnit,
scala.Function2<IN,AsyncCollector<OUT>,scala.runtime.BoxedUnit> asyncFunction,
TypeInformation<OUT> evidence$8)
Apply an asynchronous function on the input data stream.
|
<IN,OUT> DataStream<OUT> |
AsyncDataStream$.orderedWait(DataStream<IN> input,
long timeout,
TimeUnit timeUnit,
int capacity,
scala.Function2<IN,AsyncCollector<OUT>,scala.runtime.BoxedUnit> asyncFunction,
TypeInformation<OUT> evidence$7)
Apply an asynchronous function on the input data stream.
|
static <IN,OUT> DataStream<OUT> |
AsyncDataStream.orderedWait(DataStream<IN> input,
long timeout,
TimeUnit timeUnit,
int capacity,
scala.Function2<IN,AsyncCollector<OUT>,scala.runtime.BoxedUnit> asyncFunction,
TypeInformation<OUT> evidence$7)
Apply an asynchronous function on the input data stream.
|
<K> DataStream<T> |
DataStream.partitionCustom(Partitioner<K> partitioner,
scala.Function1<T,K> fun,
TypeInformation<K> evidence$4)
Partitions a DataStream on the key returned by the selector, using a custom partitioner.
|
<K> DataStream<T> |
DataStream.partitionCustom(Partitioner<K> partitioner,
int field,
TypeInformation<K> evidence$2)
Partitions a tuple DataStream on the specified key fields using a custom partitioner.
|
<K> DataStream<T> |
DataStream.partitionCustom(Partitioner<K> partitioner,
String field,
TypeInformation<K> evidence$3)
Partitions a POJO DataStream on the specified key fields using a custom partitioner.
|
<R> DataStream<R> |
ConnectedStreams.process(CoProcessFunction<IN1,IN2,R> coProcessFunction,
TypeInformation<R> evidence$3)
Applies the given
CoProcessFunction on the connected input streams,
thereby creating a transformed output stream. |
<R> DataStream<R> |
KeyedStream.process(ProcessFunction<T,R> processFunction,
TypeInformation<R> evidence$1)
Applies the given
ProcessFunction on the input stream, thereby
creating a transformed output stream. |
<T> DataStream<T> |
StreamExecutionEnvironment.readFile(FileInputFormat<T> inputFormat,
String filePath,
FileProcessingMode watchType,
long interval,
FilePathFilter filter,
TypeInformation<T> evidence$6)
Deprecated.
Use
FileInputFormat#setFilesFilter(FilePathFilter) to set a filter and
StreamExecutionEnvironment#readFile(FileInputFormat, String, FileProcessingMode, long) |
<T> DataStream<T> |
StreamExecutionEnvironment.readFile(FileInputFormat<T> inputFormat,
String filePath,
FileProcessingMode watchType,
long interval,
TypeInformation<T> evidence$7)
Reads the contents of the user-specified path based on the given
FileInputFormat . |
<T> DataStream<T> |
StreamExecutionEnvironment.readFile(FileInputFormat<T> inputFormat,
String filePath,
TypeInformation<T> evidence$5)
Reads the given file with the given input format.
|
DataStream<String> |
StreamExecutionEnvironment.readFileStream(String StreamPath,
long intervalMillis,
FileMonitoringFunction.WatchType watchType)
Creates a DataStream that contains the contents of file created while
system watches the given path.
|
DataStream<String> |
StreamExecutionEnvironment.readTextFile(String filePath)
Creates a DataStream that represents the Strings produced by reading the
given file line wise.
|
DataStream<String> |
StreamExecutionEnvironment.readTextFile(String filePath,
String charsetName)
Creates a data stream that represents the Strings produced by reading the given file
line wise.
|
DataStream<T> |
DataStream.rebalance()
Sets the partitioning of the DataStream so that the output tuples
are distributed evenly to the next component.
|
DataStream<T> |
KeyedStream.reduce(scala.Function2<T,T,T> fun)
Creates a new
DataStream by reducing the elements of this DataStream
using an associative reduce function. |
DataStream<T> |
AllWindowedStream.reduce(scala.Function2<T,T,T> function)
Applies a reduce function to the window.
|
DataStream<T> |
WindowedStream.reduce(scala.Function2<T,T,T> function)
Applies a reduce function to the window.
|
<R> DataStream<R> |
AllWindowedStream.reduce(scala.Function2<T,T,T> preAggregator,
scala.Function3<W,scala.collection.Iterable<T>,Collector<R>,scala.runtime.BoxedUnit> windowFunction,
TypeInformation<R> evidence$2)
Applies the given window function to each window.
|
<R> DataStream<R> |
WindowedStream.reduce(scala.Function2<T,T,T> preAggregator,
scala.Function4<K,W,scala.collection.Iterable<T>,Collector<R>,scala.runtime.BoxedUnit> windowFunction,
TypeInformation<R> evidence$2)
Applies the given window function to each window.
|
DataStream<T> |
KeyedStream.reduce(ReduceFunction<T> reducer)
Creates a new
DataStream by reducing the elements of this DataStream
using an associative reduce function. |
DataStream<T> |
AllWindowedStream.reduce(ReduceFunction<T> function)
Applies a reduce function to the window.
|
DataStream<T> |
WindowedStream.reduce(ReduceFunction<T> function)
Applies a reduce function to the window.
|
<R> DataStream<R> |
AllWindowedStream.reduce(ReduceFunction<T> preAggregator,
AllWindowFunction<T,R,W> windowFunction,
TypeInformation<R> evidence$1)
Applies the given window function to each window.
|
<R> DataStream<R> |
WindowedStream.reduce(ReduceFunction<T> preAggregator,
WindowFunction<T,R,K,W> function,
TypeInformation<R> evidence$1)
Applies the given window function to each window.
|
DataStream<T> |
DataStream.rescale()
Sets the partitioning of the
DataStream so that the output tuples
are distributed evenly to a subset of instances of the downstream operation. |
DataStream<T> |
SplitStream.select(scala.collection.Seq<String> outputNames)
Sets the output names for which the next operator will receive values.
|
DataStream<T> |
DataStream.setBufferTimeout(long timeoutMillis)
Sets the maximum time frequency (ms) for the flushing of the output
buffer.
|
DataStream<T> |
DataStream.setMaxParallelism(int maxParallelism) |
DataStream<T> |
DataStream.setParallelism(int parallelism)
Sets the parallelism of this operation.
|
DataStream<T> |
DataStream.setUidHash(String hash)
Sets an user provided hash for this operator.
|
DataStream<T> |
DataStream.shuffle()
Sets the partitioning of the DataStream so that the output tuples
are shuffled to the next component.
|
DataStream<T> |
DataStream.slotSharingGroup(String slotSharingGroup)
Sets the slot sharing group of this operation.
|
DataStream<String> |
StreamExecutionEnvironment.socketTextStream(String hostname,
int port,
char delimiter,
long maxRetry)
Creates a new DataStream that contains the strings received infinitely
from socket.
|
DataStream<T> |
DataStream.startNewChain()
Starts a new task chain beginning at this operator.
|
DataStream<T> |
KeyedStream.sum(int position)
Applies an aggregation that sums the data stream at the given position by the given
key.
|
DataStream<T> |
AllWindowedStream.sum(int position)
Applies an aggregation that sums the elements in the window at the given position.
|
DataStream<T> |
WindowedStream.sum(int position)
Applies an aggregation that sums the elements in the window at the given position.
|
DataStream<T> |
KeyedStream.sum(String field)
Applies an aggregation that sums the data stream at the given field by the given
key.
|
DataStream<T> |
AllWindowedStream.sum(String field)
Applies an aggregation that sums the elements in the window at the given field.
|
DataStream<T> |
WindowedStream.sum(String field)
Applies an aggregation that sums the elements in the window at the given field.
|
<R> DataStream<R> |
DataStream.transform(String operatorName,
OneInputStreamOperator<T,R> operator,
TypeInformation<R> evidence$11)
Transforms the
DataStream by using a custom OneInputStreamOperator . |
<R> DataStream<R> |
ConnectedStreams.transform(String functionName,
TwoInputStreamOperator<IN1,IN2,R> operator,
TypeInformation<R> evidence$9) |
DataStream<T> |
DataStream.uid(String uid)
Sets an ID for this operator.
|
DataStream<T> |
DataStream.union(scala.collection.Seq<DataStream<T>> dataStreams)
Creates a new DataStream by merging DataStream outputs of
the same type with each other.
|
<IN,OUT> DataStream<OUT> |
AsyncDataStream$.unorderedWait(DataStream<IN> input,
AsyncFunction<IN,OUT> asyncFunction,
long timeout,
TimeUnit timeUnit,
int capacity,
TypeInformation<OUT> evidence$1)
Apply an asynchronous function on the input data stream.
|
static <IN,OUT> DataStream<OUT> |
AsyncDataStream.unorderedWait(DataStream<IN> input,
AsyncFunction<IN,OUT> asyncFunction,
long timeout,
TimeUnit timeUnit,
int capacity,
TypeInformation<OUT> evidence$1)
Apply an asynchronous function on the input data stream.
|
<IN,OUT> DataStream<OUT> |
AsyncDataStream$.unorderedWait(DataStream<IN> input,
AsyncFunction<IN,OUT> asyncFunction,
long timeout,
TimeUnit timeUnit,
TypeInformation<OUT> evidence$2)
Apply an asynchronous function on the input data stream.
|
static <IN,OUT> DataStream<OUT> |
AsyncDataStream.unorderedWait(DataStream<IN> input,
AsyncFunction<IN,OUT> asyncFunction,
long timeout,
TimeUnit timeUnit,
TypeInformation<OUT> evidence$2)
Apply an asynchronous function on the input data stream.
|
<IN,OUT> DataStream<OUT> |
AsyncDataStream$.unorderedWait(DataStream<IN> input,
long timeout,
TimeUnit timeUnit,
scala.Function2<IN,AsyncCollector<OUT>,scala.runtime.BoxedUnit> asyncFunction,
TypeInformation<OUT> evidence$4)
Apply an asynchronous function on the input data stream.
|
static <IN,OUT> DataStream<OUT> |
AsyncDataStream.unorderedWait(DataStream<IN> input,
long timeout,
TimeUnit timeUnit,
scala.Function2<IN,AsyncCollector<OUT>,scala.runtime.BoxedUnit> asyncFunction,
TypeInformation<OUT> evidence$4)
Apply an asynchronous function on the input data stream.
|
<IN,OUT> DataStream<OUT> |
AsyncDataStream$.unorderedWait(DataStream<IN> input,
long timeout,
TimeUnit timeUnit,
int capacity,
scala.Function2<IN,AsyncCollector<OUT>,scala.runtime.BoxedUnit> asyncFunction,
TypeInformation<OUT> evidence$3)
Apply an asynchronous function on the input data stream.
|
static <IN,OUT> DataStream<OUT> |
AsyncDataStream.unorderedWait(DataStream<IN> input,
long timeout,
TimeUnit timeUnit,
int capacity,
scala.Function2<IN,AsyncCollector<OUT>,scala.runtime.BoxedUnit> asyncFunction,
TypeInformation<OUT> evidence$3)
Apply an asynchronous function on the input data stream.
|
Modifier and Type | Method and Description |
---|---|
<T2> CoGroupedStreams<T,T2> |
DataStream.coGroup(DataStream<T2> otherStream)
Creates a co-group operation.
|
<T2> ConnectedStreams<T,T2> |
DataStream.connect(DataStream<T2> dataStream)
Creates a new ConnectedStreams by connecting
DataStream outputs of different type with each other.
|
<T2> JoinedStreams<T,T2> |
DataStream.join(DataStream<T2> otherStream)
Creates a join operation.
|
<IN,OUT> DataStream<OUT> |
AsyncDataStream$.orderedWait(DataStream<IN> input,
AsyncFunction<IN,OUT> asyncFunction,
long timeout,
TimeUnit timeUnit,
int capacity,
TypeInformation<OUT> evidence$5)
Apply an asynchronous function on the input data stream.
|
static <IN,OUT> DataStream<OUT> |
AsyncDataStream.orderedWait(DataStream<IN> input,
AsyncFunction<IN,OUT> asyncFunction,
long timeout,
TimeUnit timeUnit,
int capacity,
TypeInformation<OUT> evidence$5)
Apply an asynchronous function on the input data stream.
|
<IN,OUT> DataStream<OUT> |
AsyncDataStream$.orderedWait(DataStream<IN> input,
AsyncFunction<IN,OUT> asyncFunction,
long timeout,
TimeUnit timeUnit,
TypeInformation<OUT> evidence$6)
Apply an asynchronous function on the input data stream.
|
static <IN,OUT> DataStream<OUT> |
AsyncDataStream.orderedWait(DataStream<IN> input,
AsyncFunction<IN,OUT> asyncFunction,
long timeout,
TimeUnit timeUnit,
TypeInformation<OUT> evidence$6)
Apply an asynchronous function on the input data stream.
|
<IN,OUT> DataStream<OUT> |
AsyncDataStream$.orderedWait(DataStream<IN> input,
long timeout,
TimeUnit timeUnit,
scala.Function2<IN,AsyncCollector<OUT>,scala.runtime.BoxedUnit> asyncFunction,
TypeInformation<OUT> evidence$8)
Apply an asynchronous function on the input data stream.
|
static <IN,OUT> DataStream<OUT> |
AsyncDataStream.orderedWait(DataStream<IN> input,
long timeout,
TimeUnit timeUnit,
scala.Function2<IN,AsyncCollector<OUT>,scala.runtime.BoxedUnit> asyncFunction,
TypeInformation<OUT> evidence$8)
Apply an asynchronous function on the input data stream.
|
<IN,OUT> DataStream<OUT> |
AsyncDataStream$.orderedWait(DataStream<IN> input,
long timeout,
TimeUnit timeUnit,
int capacity,
scala.Function2<IN,AsyncCollector<OUT>,scala.runtime.BoxedUnit> asyncFunction,
TypeInformation<OUT> evidence$7)
Apply an asynchronous function on the input data stream.
|
static <IN,OUT> DataStream<OUT> |
AsyncDataStream.orderedWait(DataStream<IN> input,
long timeout,
TimeUnit timeUnit,
int capacity,
scala.Function2<IN,AsyncCollector<OUT>,scala.runtime.BoxedUnit> asyncFunction,
TypeInformation<OUT> evidence$7)
Apply an asynchronous function on the input data stream.
|
<IN,OUT> DataStream<OUT> |
AsyncDataStream$.unorderedWait(DataStream<IN> input,
AsyncFunction<IN,OUT> asyncFunction,
long timeout,
TimeUnit timeUnit,
int capacity,
TypeInformation<OUT> evidence$1)
Apply an asynchronous function on the input data stream.
|
static <IN,OUT> DataStream<OUT> |
AsyncDataStream.unorderedWait(DataStream<IN> input,
AsyncFunction<IN,OUT> asyncFunction,
long timeout,
TimeUnit timeUnit,
int capacity,
TypeInformation<OUT> evidence$1)
Apply an asynchronous function on the input data stream.
|
<IN,OUT> DataStream<OUT> |
AsyncDataStream$.unorderedWait(DataStream<IN> input,
AsyncFunction<IN,OUT> asyncFunction,
long timeout,
TimeUnit timeUnit,
TypeInformation<OUT> evidence$2)
Apply an asynchronous function on the input data stream.
|
static <IN,OUT> DataStream<OUT> |
AsyncDataStream.unorderedWait(DataStream<IN> input,
AsyncFunction<IN,OUT> asyncFunction,
long timeout,
TimeUnit timeUnit,
TypeInformation<OUT> evidence$2)
Apply an asynchronous function on the input data stream.
|
<IN,OUT> DataStream<OUT> |
AsyncDataStream$.unorderedWait(DataStream<IN> input,
long timeout,
TimeUnit timeUnit,
scala.Function2<IN,AsyncCollector<OUT>,scala.runtime.BoxedUnit> asyncFunction,
TypeInformation<OUT> evidence$4)
Apply an asynchronous function on the input data stream.
|
static <IN,OUT> DataStream<OUT> |
AsyncDataStream.unorderedWait(DataStream<IN> input,
long timeout,
TimeUnit timeUnit,
scala.Function2<IN,AsyncCollector<OUT>,scala.runtime.BoxedUnit> asyncFunction,
TypeInformation<OUT> evidence$4)
Apply an asynchronous function on the input data stream.
|
<IN,OUT> DataStream<OUT> |
AsyncDataStream$.unorderedWait(DataStream<IN> input,
long timeout,
TimeUnit timeUnit,
int capacity,
scala.Function2<IN,AsyncCollector<OUT>,scala.runtime.BoxedUnit> asyncFunction,
TypeInformation<OUT> evidence$3)
Apply an asynchronous function on the input data stream.
|
static <IN,OUT> DataStream<OUT> |
AsyncDataStream.unorderedWait(DataStream<IN> input,
long timeout,
TimeUnit timeUnit,
int capacity,
scala.Function2<IN,AsyncCollector<OUT>,scala.runtime.BoxedUnit> asyncFunction,
TypeInformation<OUT> evidence$3)
Apply an asynchronous function on the input data stream.
|
Modifier and Type | Method and Description |
---|---|
<R,F> DataStream<R> |
DataStream.iterate(scala.Function1<ConnectedStreams<T,F>,scala.Tuple2<DataStream<F>,DataStream<R>>> stepFunction,
long maxWaitTimeMillis,
TypeInformation<F> evidence$5)
Initiates an iterative part of the program that creates a loop by feeding
back data streams.
|
<R,F> DataStream<R> |
DataStream.iterate(scala.Function1<ConnectedStreams<T,F>,scala.Tuple2<DataStream<F>,DataStream<R>>> stepFunction,
long maxWaitTimeMillis,
TypeInformation<F> evidence$5)
Initiates an iterative part of the program that creates a loop by feeding
back data streams.
|
<R> DataStream<R> |
DataStream.iterate(scala.Function1<DataStream<T>,scala.Tuple2<DataStream<T>,DataStream<R>>> stepFunction,
long maxWaitTimeMillis,
boolean keepPartitioning)
Initiates an iterative part of the program that creates a loop by feeding
back data streams.
|
<R> DataStream<R> |
DataStream.iterate(scala.Function1<DataStream<T>,scala.Tuple2<DataStream<T>,DataStream<R>>> stepFunction,
long maxWaitTimeMillis,
boolean keepPartitioning)
Initiates an iterative part of the program that creates a loop by feeding
back data streams.
|
<R> DataStream<R> |
DataStream.iterate(scala.Function1<DataStream<T>,scala.Tuple2<DataStream<T>,DataStream<R>>> stepFunction,
long maxWaitTimeMillis,
boolean keepPartitioning)
Initiates an iterative part of the program that creates a loop by feeding
back data streams.
|
DataStream<T> |
DataStream.union(scala.collection.Seq<DataStream<T>> dataStreams)
Creates a new DataStream by merging DataStream outputs of
the same type with each other.
|
Constructor and Description |
---|
CoGroupedStreams(DataStream<T1> input1,
DataStream<T2> input2) |
CoGroupedStreams(DataStream<T1> input1,
DataStream<T2> input2) |
JoinedStreams(DataStream<T1> input1,
DataStream<T2> input2) |
JoinedStreams(DataStream<T1> input1,
DataStream<T2> input2) |
Modifier and Type | Method and Description |
---|---|
<ACC,R> DataStream<R> |
OnWindowedStream.applyWith(ACC initialValue,
scala.Function2<ACC,T,ACC> foldFunction,
scala.Function3<K,W,scala.collection.immutable.Stream<ACC>,scala.collection.TraversableOnce<R>> windowFunction,
TypeInformation<ACC> evidence$2,
TypeInformation<R> evidence$3)
Applies the given window function to each window.
|
DataStream<T> |
OnDataStream.filterWith(scala.Function1<T,Object> fun)
Applies a predicate
fun to each item of the stream, keeping only those for which
the predicate holds |
<R> DataStream<R> |
OnConnectedStream.flatMapWith(scala.Function1<IN1,scala.collection.TraversableOnce<R>> flatMap1,
scala.Function1<IN2,scala.collection.TraversableOnce<R>> flatMap2,
TypeInformation<R> evidence$2)
Applies a CoFlatMap transformation on the connected streams.
|
<R> DataStream<R> |
OnDataStream.flatMapWith(scala.Function1<T,scala.collection.TraversableOnce<R>> fun,
TypeInformation<R> evidence$2)
Applies a function
fun to each item of the stream, producing a collection of items
that will be flattened in the resulting stream |
<R> DataStream<R> |
OnWindowedStream.foldWith(R initialValue,
scala.Function2<R,T,R> function,
TypeInformation<R> evidence$1)
Applies the given fold function to each window.
|
<R> DataStream<R> |
OnKeyedStream.foldWith(R initialValue,
scala.Function2<R,T,R> fun,
TypeInformation<R> evidence$1)
Folds the stream over a zero element with a reducer
fun |
<R> DataStream<R> |
OnConnectedStream.mapWith(scala.Function1<IN1,R> map1,
scala.Function1<IN2,R> map2,
TypeInformation<R> evidence$1)
Applies a CoMap transformation on the connected streams.
|
<R> DataStream<R> |
OnDataStream.mapWith(scala.Function1<T,R> fun,
TypeInformation<R> evidence$1)
Applies a function
fun to each item of the stream |
<O> DataStream<O> |
OnJoinedStream.projecting(scala.Function2<L,R,O> fun,
TypeInformation<O> evidence$1)
Completes the join operation with the user function that is executed
for windowed groups.
|
DataStream<T> |
OnWindowedStream.reduceWith(scala.Function2<T,T,T> function)
Applies a reduce function to the window.
|
DataStream<T> |
OnKeyedStream.reduceWith(scala.Function2<T,T,T> fun)
Applies a reducer
fun to the stream |
Constructor and Description |
---|
OnDataStream(DataStream<T> stream) |
Modifier and Type | Method and Description |
---|---|
DataStream<WindowJoin.Grade> |
WindowJoinSampleData$.getGradeSource(StreamExecutionEnvironment env,
long rate)
Continuously generates (name, grade).
|
static DataStream<WindowJoin.Grade> |
WindowJoinSampleData.getGradeSource(StreamExecutionEnvironment env,
long rate)
Continuously generates (name, grade).
|
DataStream<WindowJoin.Salary> |
WindowJoinSampleData$.getSalarySource(StreamExecutionEnvironment env,
long rate)
Continuously generates (name, salary).
|
static DataStream<WindowJoin.Salary> |
WindowJoinSampleData.getSalarySource(StreamExecutionEnvironment env,
long rate)
Continuously generates (name, salary).
|
static DataStream<WindowJoin.Person> |
WindowJoin.joinStreams(DataStream<WindowJoin.Grade> grades,
DataStream<WindowJoin.Salary> salaries,
long windowSize) |
DataStream<WindowJoin.Person> |
WindowJoin$.joinStreams(DataStream<WindowJoin.Grade> grades,
DataStream<WindowJoin.Salary> salaries,
long windowSize) |
Modifier and Type | Method and Description |
---|---|
static DataStream<WindowJoin.Person> |
WindowJoin.joinStreams(DataStream<WindowJoin.Grade> grades,
DataStream<WindowJoin.Salary> salaries,
long windowSize) |
static DataStream<WindowJoin.Person> |
WindowJoin.joinStreams(DataStream<WindowJoin.Grade> grades,
DataStream<WindowJoin.Salary> salaries,
long windowSize) |
DataStream<WindowJoin.Person> |
WindowJoin$.joinStreams(DataStream<WindowJoin.Grade> grades,
DataStream<WindowJoin.Salary> salaries,
long windowSize) |
DataStream<WindowJoin.Person> |
WindowJoin$.joinStreams(DataStream<WindowJoin.Grade> grades,
DataStream<WindowJoin.Salary> salaries,
long windowSize) |
Modifier and Type | Method and Description |
---|---|
<T> DataStream<T> |
StreamTableEnvironment.toDataStream(Table table,
TypeInformation<T> evidence$1)
Converts the given
Table into a DataStream of a specified type. |
<T> DataStream<T> |
TableConversions.toDataStream(TypeInformation<T> evidence$2)
Converts the
Table to a DataStream of the specified type. |
Modifier and Type | Method and Description |
---|---|
<T> Table |
StreamTableEnvironment.fromDataStream(DataStream<T> dataStream)
Converts the given
DataStream into a Table . |
<T> Table |
StreamTableEnvironment.fromDataStream(DataStream<T> dataStream,
scala.collection.Seq<Expression> fields)
Converts the given
DataStream into a Table with specified field names. |
<T> void |
StreamTableEnvironment.registerDataStream(String name,
DataStream<T> dataStream)
Registers the given
DataStream as table in the
TableEnvironment 's catalog. |
<T> void |
StreamTableEnvironment.registerDataStream(String name,
DataStream<T> dataStream,
scala.collection.Seq<Expression> fields)
Registers the given
DataStream as table with specified field names in the
TableEnvironment 's catalog. |
Constructor and Description |
---|
DataStreamConversions(DataStream<T> dataStream,
TypeInformation<T> inputType) |
Copyright © 2014–2017 The Apache Software Foundation. All rights reserved.