StreamingRuntimeContext (flink 1.8-SNAPSHOT API)

java.lang.Object
- org.apache.flink.api.common.functions.util.AbstractRuntimeUDFContext
- - org.apache.flink.streaming.api.operators.StreamingRuntimeContext

All Implemented Interfaces:

RuntimeContext
```
@Internal
public class StreamingRuntimeContext
extends AbstractRuntimeUDFContext
```
Implementation of the RuntimeContext, for streaming operators.

Constructor Summary

Constructors
Constructor and Description
`StreamingRuntimeContext(AbstractStreamOperator<?> operator, Environment env, Map<String,Accumulator<?,?>> accumulators)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<IN,ACC,OUT> AggregatingState<IN,OUT>`	`getAggregatingState(AggregatingStateDescriptor<IN,ACC,OUT> stateProperties)` Gets a handle to the system's key/value aggregating state.
`<RT> List<RT>`	`getBroadcastVariable(String name)` Returns the result bound to the broadcast variable identified by the given `name`.
`<T,C> C`	`getBroadcastVariableWithInitializer(String name, BroadcastVariableInitializer<T,C> initializer)` Returns the result bound to the broadcast variable identified by the given `name`.
`long`	`getBufferTimeout()` Returns the buffer timeout of the job.
`CheckpointingMode`	`getCheckpointMode()` Returns the checkpointing mode.
`<T,ACC> FoldingState<T,ACC>`	`getFoldingState(FoldingStateDescriptor<T,ACC> stateProperties)` Gets a handle to the system's key/value folding state.
`GlobalAggregateManager`	`getGlobalAggregateManager()` Returns the global aggregate manager for the current job.
`InputSplitProvider`	`getInputSplitProvider()` Returns the input split provider associated with the operator.
`<T> ListState<T>`	`getListState(ListStateDescriptor<T> stateProperties)` Gets a handle to the system's key/value list state.
`<UK,UV> MapState<UK,UV>`	`getMapState(MapStateDescriptor<UK,UV> stateProperties)` Gets a handle to the system's key/value map state.
`String`	`getOperatorUniqueID()` Returned value is guaranteed to be unique between operators within the same job and to be stable and the same across job submissions.
`ProcessingTimeService`	`getProcessingTimeService()`
`<T> ReducingState<T>`	`getReducingState(ReducingStateDescriptor<T> stateProperties)` Gets a handle to the system's key/value reducing state.
`<T> ValueState<T>`	`getState(ValueStateDescriptor<T> stateProperties)` Gets a handle to the system's key/value state.
`boolean`	`hasBroadcastVariable(String name)` Tests for the existence of the broadcast variable identified by the given `name`.
`boolean`	`isCheckpointingEnabled()` Returns true if checkpointing is enabled for the running job.

Methods inherited from class org.apache.flink.api.common.functions.util.AbstractRuntimeUDFContext
addAccumulator, getAccumulator, getAllAccumulators, getAllocationIDAsString, getAttemptNumber, getDistributedCache, getDoubleCounter, getExecutionConfig, getHistogram, getIndexOfThisSubtask, getIntCounter, getLongCounter, getMaxNumberOfParallelSubtasks, getMetricGroup, getNumberOfParallelSubtasks, getTaskName, getTaskNameWithSubtasks, getUserCodeClassLoader

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - StreamingRuntimeContext
```
public StreamingRuntimeContext(AbstractStreamOperator<?> operator,
                               Environment env,
                               Map<String,Accumulator<?,?>> accumulators)
```
- Method Detail
  - getInputSplitProvider
```
public InputSplitProvider getInputSplitProvider()
```
    Returns the input split provider associated with the operator.
    
    Returns:
    
    The input split provider.
  - getProcessingTimeService
```
public ProcessingTimeService getProcessingTimeService()
```
  - getGlobalAggregateManager
```
public GlobalAggregateManager getGlobalAggregateManager()
```
    Returns the global aggregate manager for the current job.
    
    Returns:
    
    The global aggregate manager.
  - getOperatorUniqueID
```
public String getOperatorUniqueID()
```
    Returned value is guaranteed to be unique between operators within the same job and to be stable and the same across job submissions.
    This operation is currently only supported in Streaming (DataStream) contexts.
    
    Returns:
    
    String representation of the operator's unique id.
  - hasBroadcastVariable
```
public boolean hasBroadcastVariable(String name)
```
    Description copied from interface: RuntimeContext
    
    Tests for the existence of the broadcast variable identified by the given name.
    
    Parameters:
    
    name - The name under which the broadcast variable is registered;
    
    Returns:
    
    Whether a broadcast variable exists for the given name.
  - getBroadcastVariable
```
public <RT> List<RT> getBroadcastVariable(String name)
```
    Description copied from interface: RuntimeContext
    
    Returns the result bound to the broadcast variable identified by the given name.
    IMPORTANT: The broadcast variable data structure is shared between the parallel tasks on one machine. Any access that modifies its internal state needs to be manually synchronized by the caller.
    
    Parameters:
    
    name - The name under which the broadcast variable is registered;
    
    Returns:
    
    The broadcast variable, materialized as a list of elements.
  - getBroadcastVariableWithInitializer
```
public <T,C> C getBroadcastVariableWithInitializer(String name,
                                                   BroadcastVariableInitializer<T,C> initializer)
```
    Description copied from interface: RuntimeContext
    
    Returns the result bound to the broadcast variable identified by the given name. The broadcast variable is returned as a shared data structure that is initialized with the given BroadcastVariableInitializer.
    IMPORTANT: The broadcast variable data structure is shared between the parallel tasks on one machine. Any access that modifies its internal state needs to be manually synchronized by the caller.
    
    Parameters:
    
    name - The name under which the broadcast variable is registered;
    
    initializer - The initializer that creates the shared data structure of the broadcast variable from the sequence of elements.
    
    Returns:
    
    The broadcast variable, materialized as a list of elements.
  - getState
```
public <T> ValueState<T> getState(ValueStateDescriptor<T> stateProperties)
```
    Description copied from interface: RuntimeContext
    Gets a handle to the system's key/value state. The key/value state is only accessible if the function is executed on a KeyedStream. On each access, the state exposes the value for the key of the element currently processed by the function. Each function may have multiple partitioned states, addressed with different names.
    Because the scope of each value is the key of the currently processed element, and the elements are distributed by the Flink runtime, the system can transparently scale out and redistribute the state and KeyedStream.
    The following code example shows how to implement a continuous counter that counts how many times elements of a certain key occur, and emits an updated count for that element on each occurrence.
```
 DataStream<MyType> stream = ...;
 KeyedStream<MyType> keyedStream = stream.keyBy("id");

 keyedStream.map(new RichMapFunction<MyType, Tuple2<MyType, Long>>() {

     private ValueState<Long> state;

     public void open(Configuration cfg) {
         state = getRuntimeContext().getState(
                 new ValueStateDescriptor<Long>("count", LongSerializer.INSTANCE, 0L));
     }

     public Tuple2<MyType, Long> map(MyType value) {
         long count = state.value() + 1;
         state.update(count);
         return new Tuple2<>(value, count);
     }
 });
 
```
    Specified by:
    
    getState in interface RuntimeContext
    
    Overrides:
    
    getState in class AbstractRuntimeUDFContext
    
    Type Parameters:
    
    T - The type of value stored in the state.
    
    Parameters:
    
    stateProperties - The descriptor defining the properties of the stats.
    
    Returns:
    
    The partitioned state object.
  - getListState
```
public <T> ListState<T> getListState(ListStateDescriptor<T> stateProperties)
```
    Description copied from interface: RuntimeContext
    Gets a handle to the system's key/value list state. This state is similar to the state accessed via RuntimeContext.getState(ValueStateDescriptor), but is optimized for state that holds lists. One can add elements to the list, or retrieve the list as a whole.
    This state is only accessible if the function is executed on a KeyedStream.
```
 DataStream<MyType> stream = ...;
 KeyedStream<MyType> keyedStream = stream.keyBy("id");

 keyedStream.map(new RichFlatMapFunction<MyType, List<MyType>>() {

     private ListState<MyType> state;

     public void open(Configuration cfg) {
         state = getRuntimeContext().getListState(
                 new ListStateDescriptor<>("myState", MyType.class));
     }

     public void flatMap(MyType value, Collector<MyType> out) {
         if (value.isDivider()) {
             for (MyType t : state.get()) {
                 out.collect(t);
             }
         } else {
             state.add(value);
         }
     }
 });
 
```
    Specified by:
    
    getListState in interface RuntimeContext
    
    Overrides:
    
    getListState in class AbstractRuntimeUDFContext
    
    Type Parameters:
    
    T - The type of value stored in the state.
    
    Parameters:
    
    stateProperties - The descriptor defining the properties of the stats.
    
    Returns:
    
    The partitioned state object.
  - getReducingState
```
public <T> ReducingState<T> getReducingState(ReducingStateDescriptor<T> stateProperties)
```
    Description copied from interface: RuntimeContext
    Gets a handle to the system's key/value reducing state. This state is similar to the state accessed via RuntimeContext.getState(ValueStateDescriptor), but is optimized for state that aggregates values.
    This state is only accessible if the function is executed on a KeyedStream.
```
 DataStream<MyType> stream = ...;
 KeyedStream<MyType> keyedStream = stream.keyBy("id");

 keyedStream.map(new RichMapFunction<MyType, List<MyType>>() {

     private ReducingState<Long> state;

     public void open(Configuration cfg) {
         state = getRuntimeContext().getReducingState(
                 new ReducingStateDescriptor<>("sum", (a, b) -> a + b, Long.class));
     }

     public Tuple2<MyType, Long> map(MyType value) {
         state.add(value.count());
         return new Tuple2<>(value, state.get());
     }
 });

 
```
    Specified by:
    
    getReducingState in interface RuntimeContext
    
    Overrides:
    
    getReducingState in class AbstractRuntimeUDFContext
    
    Type Parameters:
    
    T - The type of value stored in the state.
    
    Parameters:
    
    stateProperties - The descriptor defining the properties of the stats.
    
    Returns:
    
    The partitioned state object.
  - getAggregatingState
```
public <IN,ACC,OUT> AggregatingState<IN,OUT> getAggregatingState(AggregatingStateDescriptor<IN,ACC,OUT> stateProperties)
```
    Description copied from interface: RuntimeContext
    Gets a handle to the system's key/value aggregating state. This state is similar to the state accessed via RuntimeContext.getState(ValueStateDescriptor), but is optimized for state that aggregates values with different types.
    This state is only accessible if the function is executed on a KeyedStream.
```
 DataStream<MyType> stream = ...;
 KeyedStream<MyType> keyedStream = stream.keyBy("id");
 AggregateFunction<...> aggregateFunction = ...

 keyedStream.map(new RichMapFunction<MyType, List<MyType>>() {

     private AggregatingState<MyType, Long> state;

     public void open(Configuration cfg) {
         state = getRuntimeContext().getAggregatingState(
                 new AggregatingStateDescriptor<>("sum", aggregateFunction, Long.class));
     }

     public Tuple2<MyType, Long> map(MyType value) {
         state.add(value);
         return new Tuple2<>(value, state.get());
     }
 });

 
```
    Specified by:
    
    getAggregatingState in interface RuntimeContext
    
    Overrides:
    
    getAggregatingState in class AbstractRuntimeUDFContext
    
    Type Parameters:
    
    IN - The type of the values that are added to the state.
    
    ACC - The type of the accumulator (intermediate aggregation state).
    
    OUT - The type of the values that are returned from the state.
    
    Parameters:
    
    stateProperties - The descriptor defining the properties of the stats.
    
    Returns:
    
    The partitioned state object.
  - getFoldingState
```
public <T,ACC> FoldingState<T,ACC> getFoldingState(FoldingStateDescriptor<T,ACC> stateProperties)
```
    Description copied from interface: RuntimeContext
    Gets a handle to the system's key/value folding state. This state is similar to the state accessed via RuntimeContext.getState(ValueStateDescriptor), but is optimized for state that aggregates values with different types.
    This state is only accessible if the function is executed on a KeyedStream.
```
 DataStream<MyType> stream = ...;
 KeyedStream<MyType> keyedStream = stream.keyBy("id");

 keyedStream.map(new RichMapFunction<MyType, List<MyType>>() {

     private FoldingState<MyType, Long> state;

     public void open(Configuration cfg) {
         state = getRuntimeContext().getFoldingState(
                 new FoldingStateDescriptor<>("sum", 0L, (a, b) -> a.count() + b, Long.class));
     }

     public Tuple2<MyType, Long> map(MyType value) {
         state.add(value);
         return new Tuple2<>(value, state.get());
     }
 });

 
```
    Specified by:
    
    getFoldingState in interface RuntimeContext
    
    Overrides:
    
    getFoldingState in class AbstractRuntimeUDFContext
    
    Type Parameters:
    
    T - Type of the values folded in the other state
    
    ACC - Type of the value in the state
    
    Parameters:
    
    stateProperties - The descriptor defining the properties of the stats.
    
    Returns:
    
    The partitioned state object.
  - getMapState
```
public <UK,UV> MapState<UK,UV> getMapState(MapStateDescriptor<UK,UV> stateProperties)
```
    Description copied from interface: RuntimeContext
    Gets a handle to the system's key/value map state. This state is similar to the state accessed via RuntimeContext.getState(ValueStateDescriptor), but is optimized for state that is composed of user-defined key-value pairs
    This state is only accessible if the function is executed on a KeyedStream.
```
 DataStream<MyType> stream = ...;
 KeyedStream<MyType> keyedStream = stream.keyBy("id");

 keyedStream.map(new RichMapFunction<MyType, List<MyType>>() {

     private MapState<MyType, Long> state;

     public void open(Configuration cfg) {
         state = getRuntimeContext().getMapState(
                 new MapStateDescriptor<>("sum", MyType.class, Long.class));
     }

     public Tuple2<MyType, Long> map(MyType value) {
         return new Tuple2<>(value, state.get(value));
     }
 });

 
```
    Specified by:
    
    getMapState in interface RuntimeContext
    
    Overrides:
    
    getMapState in class AbstractRuntimeUDFContext
    
    Type Parameters:
    
    UK - The type of the user keys stored in the state.
    
    UV - The type of the user values stored in the state.
    
    Parameters:
    
    stateProperties - The descriptor defining the properties of the stats.
    
    Returns:
    
    The partitioned state object.
  - isCheckpointingEnabled
```
public boolean isCheckpointingEnabled()
```
    Returns true if checkpointing is enabled for the running job.
    
    Returns:
    
    true if checkpointing is enabled.
  - getCheckpointMode
```
public CheckpointingMode getCheckpointMode()
```
    Returns the checkpointing mode.
    
    Returns:
    
    checkpointing mode
  - getBufferTimeout
```
public long getBufferTimeout()
```
    Returns the buffer timeout of the job.
    
    Returns:
    
    buffer timeout (in milliseconds)

Back to Flink Website

Class StreamingRuntimeContext

Constructor Summary

Method Summary

Methods inherited from class org.apache.flink.api.common.functions.util.AbstractRuntimeUDFContext

Methods inherited from class java.lang.Object

Constructor Detail

StreamingRuntimeContext

Method Detail

getInputSplitProvider

getProcessingTimeService

getGlobalAggregateManager

getOperatorUniqueID

hasBroadcastVariable

getBroadcastVariable

getBroadcastVariableWithInitializer

getState

getListState

getReducingState

getAggregatingState

getFoldingState

getMapState

isCheckpointingEnabled

getCheckpointMode

getBufferTimeout

Back to Flink Website