Package org.apache.flink.runtime.state

Interface Summary

Interface	Description
BackendWritableBroadcastState<K,V>	An interface with methods related to the interplay between the Broadcast State and the OperatorStateBackend.
CheckpointListener	This interface must be implemented by functions/operations that want to receive a commit notification once a checkpoint has been completely acknowledged by all participants.
CheckpointStorage	Implementations of this interface should implement methods acting as an administration role for checkpoint storage, which defined in CheckpointStorageCoordinatorView.
CheckpointStorageCoordinatorView	This interface creates a CheckpointStorageLocation to which an individual checkpoint or savepoint is stored.
CheckpointStorageLocation	A storage location for one particular checkpoint, offering data persistent, metadata persistence, and lifecycle/cleanup methods.
CheckpointStorageWorkerView	This interface implements the durable storage of checkpoint data and metadata streams.
CheckpointStreamFactory	A factory for checkpoint output streams, which are used to persist data for checkpoints.
CheckpointStreamWithResultProvider	Interface that provides access to a CheckpointStateOutputStream and a method to provide the SnapshotResult.
CompletedCheckpointStorageLocation	The CompletedCheckpointStorageLocation describes the storage aspect of a completed checkpoint.
CompositeStateHandle	Base of all snapshots that are taken by StateBackends and some other components in tasks.
ConfigurableStateBackend	An interface for state backends that pick up additional parameters from a configuration.
FunctionInitializationContext	This interface provides a context in which user functions can initialize by registering to managed state (i.e.
FunctionSnapshotContext	This interface provides a context in which user functions that use managed state (i.e.
IncrementalKeyedStateHandle	Common interface to all incremental KeyedStateHandle.
InternalPriorityQueue<T>	Interface for collection that gives in order access to elements w.r.t their priority.
Keyed<K>	Interface for objects that have a key attribute.
KeyedStateBackend<K>	A keyed state backend provides methods for managing keyed state.
KeyedStateBackend.KeySelectionListener<K>	Listener is given a callback when KeyedStateBackend.setCurrentKey(K) is called (key context changes).
KeyedStateFactory	This factory produces concrete internal state objects.
KeyedStateFunction<K,S extends org.apache.flink.api.common.state.State>	A function to be applied to all keyed states.
KeyedStateHandle	Base for the handles of the checkpointed states in keyed streams.
KeyExtractorFunction<T>	Function to extract a key from a given object.
KeyGroupedInternalPriorityQueue<T>	This interface exists as (temporary) adapter between the new InternalPriorityQueue and the old way in which timers are written in a snapshot.
KeyGroupPartitioner.ElementReaderFunction<T>	This functional interface defines how one element is read from a DataInputView.
KeyGroupPartitioner.ElementWriterFunction<T>	This functional interface defines how one element is written to a DataOutputView.
KeyGroupPartitioner.KeyGroupElementsConsumer<T>	Functional interface to consume elements from a key group.
KeyGroupsList	This interface offers ordered random read access to multiple key group ids.
LocalRecoveryDirectoryProvider	Provides directories for local recovery.
ManagedInitializationContext	This interface provides a context in which operators can initialize by registering to managed state (i.e.
ManagedSnapshotContext	This interface provides a context in which operators that use managed state (i.e.
OperatorStateBackend	Interface that combines both, the user facing OperatorStateStore interface and the system interface SnapshotStrategy
OperatorStateHandle	Interface of a state handle for operator state.
OwnedTaskLocalStateStore	This interface represents the administrative interface to TaskLocalStateStore, that only the owner of the object should see.
PriorityComparable<T>	Interface for objects that can be compared by priority.
PriorityComparator<T>	This interface works similar to Comparable and is used to prioritize between two objects.
PriorityQueueSetFactory	Factory for KeyGroupedInternalPriorityQueue instances.
RestoreOperation<R>	Interface for restore operation.
RetrievableStateHandle<T extends Serializable>	Handle to state that can be read back again via RetrievableStateHandle.retrieveState().
SharedStateRegistryFactory	Simple factory to produce SharedStateRegistry objects.
SnapshotStrategy<S extends StateObject>	Interface for different snapshot approaches in state backends.
StateBackend	A State Backend defines how the state of a streaming application is stored and checkpointed.
StateBackendBuilder<T,E extends Throwable>	A mutable builder to build a state backend instance.
StateBackendFactory<T extends StateBackend>	A factory to create a specific state backend.
StateEntry<K,N,S>	Interface of entries in a state backend.
StateInitializationContext	This interface provides a context in which operators can initialize by registering to managed state (i.e.
StateObject	Base of all handles that represent checkpointed state in some form.
StateSnapshot	General interface for state snapshots that should be written partitioned by key-groups.
StateSnapshot.StateKeyGroupWriter	Interface for writing a snapshot that is partitioned into key-groups.
StateSnapshotContext	This interface provides a context in which operators that use managed (i.e.
StateSnapshotKeyGroupReader	Interface for state de-serialization into StateTables by key-group.
StateSnapshotRestore	Interface to deal with state snapshot and restore of state.
StateSnapshotTransformer<T>	Transformer of state values which are included or skipped in the snapshot.
StateSnapshotTransformer.CollectionStateSnapshotTransformer<T>	Collection state specific transformer which says how to transform entries of the collection.
StateSnapshotTransformer.StateSnapshotTransformFactory<T>	This factory creates state transformers depending on the form of values to transform.
StateTransformationFunction<S,T>	Interface for a binary function that is used for push-down of state transformation into state backends.
StreamStateHandle	A StateObject that represents state that was written to a stream.
TaskLocalStateStore	Classes that implement this interface serve as a task-manager-level local storage for local checkpointed state.
TaskStateManager	This interface provides methods to report and retrieve state for a task.

Class Summary

Class	Description
AbstractKeyedStateBackend<K>	Base implementation of KeyedStateBackend.
AbstractKeyedStateBackendBuilder<K>	An abstract base implementation of the StateBackendBuilder interface.
AbstractSnapshotStrategy<T extends StateObject>	Abstract base class for implementing SnapshotStrategy, that gives a consistent logging across state backends.
AbstractStateBackend	An abstract base implementation of the StateBackend interface.
ArrayListSerializer<T>
ArrayListSerializerSnapshot<T>	Snapshot class for the ArrayListSerializer.
AsyncSnapshotCallable<T>	Base class that outlines the strategy for asynchronous snapshots.
BoundedInputStream	Wrapper around a FSDataInputStream to limit the maximum read offset.
ChainedStateHandle<T extends StateObject>	Handle to state handles for the operators in an operator chain.
CheckpointMetadataOutputStream	An output stream for checkpoint metadata.
CheckpointStorageLocationReference	A reference to a storage location.
CheckpointStreamFactory.CheckpointStateOutputStream	A dedicated output stream that produces a StreamStateHandle when closed.
CheckpointStreamWithResultProvider.PrimaryAndSecondaryStream	Implementation of CheckpointStreamWithResultProvider that creates both, the primary/remote/jm-owned state and the secondary/local/tm-owned state.
CheckpointStreamWithResultProvider.PrimaryStreamOnly	Implementation of CheckpointStreamWithResultProvider that only creates the primary/remote/jm-owned state.
DefaultKeyedStateStore	Default implementation of KeyedStateStore that currently forwards state registration to a RuntimeContext.
DefaultOperatorStateBackend	Default implementation of OperatorStateStore that provides the ability to make snapshots.
DefaultOperatorStateBackendBuilder	Builder class for DefaultOperatorStateBackend which handles all necessary initializations and clean ups.
DirectoryKeyedStateHandle	This class is a keyed state handle based on a directory.
DirectoryStateHandle	This state handle represents a directory.
DoneFuture<T>	A Future that is always done and will just yield the object that was given at creation time.
DuplicatingCheckpointOutputStream	A CheckpointStateOutputStream that wraps a primary and a secondary CheckpointStateOutputStream and duplicates all writes into both streams.
HeapBroadcastState<K,V>	A Broadcast State backed a heap-based Map.
IncrementalLocalKeyedStateHandle	State handle for local copies of IncrementalRemoteKeyedStateHandle.
IncrementalRemoteKeyedStateHandle	The handle to states of an incremental snapshot.
KeyedBackendSerializationProxy<K>	Serialization proxy for all meta data in keyed state backends.
KeyedStateCheckpointOutputStream	Checkpoint output stream that allows to write raw keyed state in a partitioned way, split into key-groups.
KeyGroupPartitioner<T>	Class that contains the base algorithm for partitioning data into key-groups.
KeyGroupRange	This class defines a range of key-group indexes.
KeyGroupRangeAssignment
KeyGroupRangeOffsets	This class combines a key-group range with offsets that correspond to the key-groups in the range.
KeyGroupsStateHandle	A handle to the partitioned stream operator state after it has been checkpointed.
KeyGroupStatePartitionStreamProvider	This class provides access to an input stream that contains state data for one key group and the key group id.
LocalRecoveryConfig	This class encapsulates the completed configuration for local recovery, i.e.
LocalRecoveryDirectoryProviderImpl	Implementation of LocalRecoveryDirectoryProvider.
NonClosingCheckpointOutputStream<T extends StreamStateHandle>	Abstract class to implement custom checkpoint output streams which should not be closable for user code.
NoOpTaskLocalStateStoreImpl	This class implements a TaskLocalStateStore with no functionality and is used when local recovery is disabled.
OperatorBackendSerializationProxy	Serialization proxy for all meta data in operator state backends.
OperatorStateCheckpointOutputStream	Checkpoint output stream that allows to write raw operator state in a partitioned way.
OperatorStateHandle.StateMetaInfo	Meta information about the operator state handle.
OperatorStateRestoreOperation	Implementation of operator state restore operation.
OperatorStreamStateHandle	State handle for partitionable operator state.
PartitionableListState<S>	Implementation of operator list state.
PlaceholderStreamStateHandle	A placeholder state handle for shared state that will replaced by an original that was created in a previous checkpoint.
RegisteredBroadcastStateBackendMetaInfo<K,V>
RegisteredKeyValueStateBackendMetaInfo<N,S>	Compound meta information for a registered state in a keyed state backend.
RegisteredOperatorStateBackendMetaInfo<S>	Compound meta information for a registered state in an operator state backend.
RegisteredPriorityQueueStateBackendMetaInfo<T>	Meta information about a priority queue state in a backend.
RegisteredStateMetaInfoBase	Base class for all registered state in state backends.
RetrievableStreamStateHandle<T extends Serializable>	Wrapper around a StreamStateHandle to make the referenced state object retrievable trough a simple get call.
SharedStateRegistry	This registry manages state that is shared across (incremental) checkpoints, and is responsible for deleting shared state that is no longer used in any valid checkpoint.
SharedStateRegistry.Result	The result of an attempt to (un)/reference state
SharedStateRegistryKey	This class represents a key that uniquely identifies (on a logical level) state handles for registration in the SharedStateRegistry.
SnappyStreamCompressionDecorator	This implementation decorates the stream with snappy compression.
SnapshotDirectory	This class represents a directory that is the target for a state snapshot.
SnapshotResult<T extends StateObject>	This class contains the combined results from the snapshot of a state backend: A state object representing the state that will be reported to the Job Manager to acknowledge the checkpoint. A state object that represents the state for the TaskLocalStateStoreImpl. Both state objects are optional and can be null, e.g.
StateBackendLoader	This class contains utility methods to load state backends from configurations.
StateEntry.SimpleStateEntry<K,N,S>
StateHandleID	Unique ID that allows for logical comparison between state handles.
StateInitializationContextImpl	Default implementation of StateInitializationContext.
StatePartitionStreamProvider	This class provides access to input streams that contain data of one state partition of a partitionable state.
StateSerializerProvider<T>	A StateSerializerProvider wraps logic on how to obtain serializers for registered state, either with the previous schema of state in checkpoints or the current schema of state.
StateSnapshotContextSynchronousImpl	This class is a default implementation for StateSnapshotContext.
StateSnapshotTransformers	Collection of common state snapshot transformers and their factories.
StateSnapshotTransformers.ListStateSnapshotTransformer<T>	General implementation of list state transformer.
StateSnapshotTransformers.ListStateSnapshotTransformFactory<T>
StateSnapshotTransformers.MapStateSnapshotTransformer<K,V>	General implementation of map state transformer.
StateSnapshotTransformers.MapStateSnapshotTransformFactory<K,V>
StateSnapshotTransformers.StateSnapshotTransformFactoryWrapAdaptor<S,T>
StateUtil	Helpers for StateObject related code.
StreamCompressionDecorator	Implementations of this interface decorate streams with a compression scheme.
TaskExecutorLocalStateStoresManager	This class holds the all TaskLocalStateStoreImpl objects for a task executor (manager).
TaskLocalStateStoreImpl	Main implementation of a TaskLocalStateStore.
TaskStateManagerImpl	This class is the default implementation of TaskStateManager and collaborates with the job manager through CheckpointResponder) as well as a task-manager-local state store.
UncompressedStreamCompressionDecorator	This implementation does not decorate the stream with any compression.
VoidNamespace	Singleton placeholder class for state without a namespace.
VoidNamespaceSerializer	Serializer for VoidNamespace.
VoidNamespaceSerializer.VoidNamespaceSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
VoidNamespaceTypeInfo	TypeInformation for VoidNamespace.

Enum Summary

Enum	Description
CheckpointedStateScope	The scope for a chunk of checkpointed state.
OperatorStateHandle.Mode	The modes that determine how an OperatorStreamStateHandle is assigned to tasks during restore.
StateSnapshotTransformer.CollectionStateSnapshotTransformer.TransformStrategy

Exception Summary

Exception	Description
BackendBuildingException	Exceptions which indicate that a state backend building has failed.