@Override public <N, T, ACC, R> InternalAggregatingState<N, T, R> createAggregatingState( TypeSerializer<N> namespaceSerializer, AggregatingStateDescriptor<T, ACC, R> stateDesc) throws Exception { StateTable<K, N, ACC> stateTable = tryRegisterStateTable(namespaceSerializer, stateDesc); return new HeapAggregatingState<>(stateDesc, stateTable, keySerializer, namespaceSerializer); }
@Override public <N, T> InternalReducingState<N, T> createReducingState( TypeSerializer<N> namespaceSerializer, ReducingStateDescriptor<T> stateDesc) throws Exception { StateTable<K, N, T> stateTable = tryRegisterStateTable(namespaceSerializer, stateDesc); return new HeapReducingState<>(stateDesc, stateTable, keySerializer, namespaceSerializer); }
@Override public <N, T, ACC> InternalFoldingState<N, T, ACC> createFoldingState( TypeSerializer<N> namespaceSerializer, FoldingStateDescriptor<T, ACC> stateDesc) throws Exception { StateTable<K, N, ACC> stateTable = tryRegisterStateTable(namespaceSerializer, stateDesc); return new HeapFoldingState<>(stateDesc, stateTable, keySerializer, namespaceSerializer); }
@Override public <N, V> InternalValueState<N, V> createValueState( TypeSerializer<N> namespaceSerializer, ValueStateDescriptor<V> stateDesc) throws Exception { StateTable<K, N, V> stateTable = tryRegisterStateTable(namespaceSerializer, stateDesc); return new HeapValueState<>(stateDesc, stateTable, keySerializer, namespaceSerializer); }
@Override @Nonnull public <N, SV, SEV, S extends State, IS extends S> IS createInternalState( @Nonnull TypeSerializer<N> namespaceSerializer, @Nonnull StateDescriptor<S, SV> stateDesc, @Nonnull StateSnapshotTransformFactory<SEV> snapshotTransformFactory) throws Exception { StateFactory stateFactory = STATE_FACTORIES.get(stateDesc.getClass()); if (stateFactory == null) { String message = String.format("State %s is not supported by %s", stateDesc.getClass(), this.getClass()); throw new FlinkRuntimeException(message); } StateTable<K, N, SV> stateTable = tryRegisterStateTable( namespaceSerializer, stateDesc, getStateSnapshotTransformer(stateDesc, snapshotTransformFactory)); return stateFactory.createState(stateDesc, stateTable, keySerializer); }
@Override @Nonnull public <N, SV, SEV, S extends State, IS extends S> IS createInternalState( @Nonnull TypeSerializer<N> namespaceSerializer, @Nonnull StateDescriptor<S, SV> stateDesc, @Nonnull StateSnapshotTransformFactory<SEV> snapshotTransformFactory) throws Exception { StateFactory stateFactory = STATE_FACTORIES.get(stateDesc.getClass()); if (stateFactory == null) { String message = String.format("State %s is not supported by %s", stateDesc.getClass(), this.getClass()); throw new FlinkRuntimeException(message); } StateTable<K, N, SV> stateTable = tryRegisterStateTable( namespaceSerializer, stateDesc, getStateSnapshotTransformer(stateDesc, snapshotTransformFactory)); return stateFactory.createState(stateDesc, stateTable, keySerializer); }
@Override public <N, V> InternalValueState<K, N, V> createValueState( TypeSerializer<N> namespaceSerializer, ValueStateDescriptor<V> stateDesc) throws Exception { StateTable<K, N, V> stateTable = tryRegisterStateTable(namespaceSerializer, stateDesc); return new HeapValueState<>( stateTable, keySerializer, stateTable.getStateSerializer(), stateTable.getNamespaceSerializer(), stateDesc.getDefaultValue()); }
@Override public <N, T> InternalListState<K, N, T> createListState( TypeSerializer<N> namespaceSerializer, ListStateDescriptor<T> stateDesc) throws Exception { StateTable<K, N, List<T>> stateTable = tryRegisterStateTable(namespaceSerializer, stateDesc); return new HeapListState<>( stateTable, keySerializer, stateTable.getStateSerializer(), stateTable.getNamespaceSerializer(), stateDesc.getDefaultValue()); }
@Override protected <N, UK, UV> InternalMapState<K, N, UK, UV> createMapState( TypeSerializer<N> namespaceSerializer, MapStateDescriptor<UK, UV> stateDesc) throws Exception { StateTable<K, N, Map<UK, UV>> stateTable = tryRegisterStateTable(namespaceSerializer, stateDesc); return new HeapMapState<>( stateTable, keySerializer, stateTable.getStateSerializer(), stateTable.getNamespaceSerializer(), stateDesc.getDefaultValue()); }
@Override public <N, T, ACC> InternalFoldingState<K, N, T, ACC> createFoldingState( TypeSerializer<N> namespaceSerializer, FoldingStateDescriptor<T, ACC> stateDesc) throws Exception { StateTable<K, N, ACC> stateTable = tryRegisterStateTable(namespaceSerializer, stateDesc); return new HeapFoldingState<>( stateTable, keySerializer, stateTable.getStateSerializer(), stateTable.getNamespaceSerializer(), stateDesc.getDefaultValue(), stateDesc.getFoldFunction()); }
@Override public <N, T> InternalReducingState<K, N, T> createReducingState( TypeSerializer<N> namespaceSerializer, ReducingStateDescriptor<T> stateDesc) throws Exception { StateTable<K, N, T> stateTable = tryRegisterStateTable(namespaceSerializer, stateDesc); return new HeapReducingState<>( stateTable, keySerializer, stateTable.getStateSerializer(), stateTable.getNamespaceSerializer(), stateDesc.getDefaultValue(), stateDesc.getReduceFunction()); }
@Override public <N, T, ACC, R> InternalAggregatingState<K, N, T, ACC, R> createAggregatingState( TypeSerializer<N> namespaceSerializer, AggregatingStateDescriptor<T, ACC, R> stateDesc) throws Exception { StateTable<K, N, ACC> stateTable = tryRegisterStateTable(namespaceSerializer, stateDesc); return new HeapAggregatingState<>( stateTable, keySerializer, stateTable.getStateSerializer(), stateTable.getNamespaceSerializer(), stateDesc.getDefaultValue(), stateDesc.getAggregateFunction()); }
@Override public <N, T> InternalListState<N, T> createListState( TypeSerializer<N> namespaceSerializer, ListStateDescriptor<T> stateDesc) throws Exception { // the list state does some manual mapping, because the state is typed to the generic // 'List' interface, but we want to use an implementation typed to ArrayList // using a more specialized implementation opens up runtime optimizations StateTable<K, N, ArrayList<T>> stateTable = tryRegisterStateTable( stateDesc.getName(), stateDesc.getType(), namespaceSerializer, new ArrayListSerializer<T>(stateDesc.getElementSerializer())); return new HeapListState<>(stateDesc, stateTable, keySerializer, namespaceSerializer); }
@Override public <N, UK, UV> InternalMapState<N, UK, UV> createMapState(TypeSerializer<N> namespaceSerializer, MapStateDescriptor<UK, UV> stateDesc) throws Exception { StateTable<K, N, HashMap<UK, UV>> stateTable = tryRegisterStateTable( stateDesc.getName(), stateDesc.getType(), namespaceSerializer, new HashMapSerializer<>(stateDesc.getKeySerializer(), stateDesc.getValueSerializer())); return new HeapMapState<>(stateDesc, stateTable, keySerializer, namespaceSerializer); }
private <N, V> StateTable<K, N, V> tryRegisterStateTable( String stateName, StateDescriptor.Type stateType, TypeSerializer<N> namespaceSerializer, TypeSerializer<V> valueSerializer) throws StateMigrationException { final RegisteredKeyedBackendStateMetaInfo<N, V> newMetaInfo = new RegisteredKeyedBackendStateMetaInfo<>(stateType, stateName, namespaceSerializer, valueSerializer); @SuppressWarnings("unchecked") StateTable<K, N, V> stateTable = (StateTable<K, N, V>) stateTables.get(stateName); if (stateTable == null) { stateTable = newStateTable(newMetaInfo); stateTables.put(stateName, stateTable); } else { // TODO with eager registration in place, these checks should be moved to restorePartitionedState() Preconditions.checkState( stateName.equals(stateTable.getMetaInfo().getName()), "Incompatible state names. " + "Was [" + stateTable.getMetaInfo().getName() + "], " + "registered with [" + newMetaInfo.getName() + "]."); if (!newMetaInfo.getStateType().equals(StateDescriptor.Type.UNKNOWN) && !stateTable.getMetaInfo().getStateType().equals(StateDescriptor.Type.UNKNOWN)) { Preconditions.checkState( newMetaInfo.getStateType().equals(stateTable.getMetaInfo().getStateType()), "Incompatible state types. " +