org.apache.flink.api.common.state.FoldingState Java Examples

/**
 * Verify that an empty {@code FoldingState} yields {@code null}.
 */
@Test
public void testFoldingStateDefaultValue() throws Exception {
	AbstractKeyedStateBackend<Integer> backend = createKeyedBackend(IntSerializer.INSTANCE);

	FoldingStateDescriptor<Integer, String> kvId =
			new FoldingStateDescriptor<>("id", "Fold-Initial:", new AppendingFold(), String.class);

	FoldingState<Integer, String> state = backend.getPartitionedState(
			VoidNamespace.INSTANCE,
			VoidNamespaceSerializer.INSTANCE, kvId);

	backend.setCurrentKey(1);
	assertNull(state.get());

	state.add(1);
	state.add(2);
	assertEquals("Fold-Initial:,1,2", state.get());

	state.clear();
	assertNull(state.get());

	backend.dispose();
}
 

/**
 * Verify that an empty {@code FoldingState} yields {@code null}.
 */
@Test
public void testFoldingStateDefaultValue() throws Exception {
	AbstractKeyedStateBackend<Integer> backend = createKeyedBackend(IntSerializer.INSTANCE);

	FoldingStateDescriptor<Integer, String> kvId =
			new FoldingStateDescriptor<>("id", "Fold-Initial:", new AppendingFold(), String.class);

	FoldingState<Integer, String> state = backend.getPartitionedState(
			VoidNamespace.INSTANCE,
			VoidNamespaceSerializer.INSTANCE, kvId);

	backend.setCurrentKey(1);
	assertNull(state.get());

	state.add(1);
	state.add(2);
	assertEquals("Fold-Initial:,1,2", state.get());

	state.clear();
	assertNull(state.get());

	backend.dispose();
}
 

/**
 * Verify that an empty {@code FoldingState} yields {@code null}.
 */
@Test
public void testFoldingStateDefaultValue() throws Exception {
	AbstractKeyedStateBackend<Integer> backend = createKeyedBackend(IntSerializer.INSTANCE);

	FoldingStateDescriptor<Integer, String> kvId =
			new FoldingStateDescriptor<>("id", "Fold-Initial:", new AppendingFold(), String.class);

	FoldingState<Integer, String> state = backend.getPartitionedState(
			VoidNamespace.INSTANCE,
			VoidNamespaceSerializer.INSTANCE, kvId);

	backend.setCurrentKey(1);
	assertNull(state.get());

	state.add(1);
	state.add(2);
	assertEquals("Fold-Initial:,1,2", state.get());

	state.clear();
	assertNull(state.get());

	backend.dispose();
}
 

@Override
@PublicEvolving
@Deprecated
public <T, ACC> FoldingState<T, ACC> getFoldingState(FoldingStateDescriptor<T, ACC> stateProperties) {
	throw new UnsupportedOperationException(
			"This state is only accessible by functions executed on a KeyedStream");
}
 

@Override
public <T, ACC> FoldingState<T, ACC> getFoldingState(FoldingStateDescriptor<T, ACC> stateProperties) {
	requireNonNull(stateProperties, "The state properties must not be null");
	try {
		stateProperties.initializeSerializerUnlessSet(executionConfig);
		return getPartitionedState(stateProperties);
	} catch (Exception e) {
		throw new RuntimeException("Error while getting state", e);
	}
}
 

@Override
public <T, ACC> FoldingState<T, ACC> getFoldingState(FoldingStateDescriptor<T, ACC> stateProperties) {
	requireNonNull(stateProperties, "The state properties must not be null");
	try {
		stateProperties.initializeSerializerUnlessSet(executionConfig);
		return getPartitionedState(stateProperties);
	} catch (Exception e) {
		throw new RuntimeException("Error while getting state", e);
	}
}
 

@Override
public <T, ACC> FoldingState<T, ACC> getFoldingState(FoldingStateDescriptor<T, ACC> stateProperties) {
	requireNonNull(stateProperties, "The state properties must not be null");
	try {
		stateProperties.initializeSerializerUnlessSet(executionConfig);
		return getPartitionedState(stateProperties);
	} catch (Exception e) {
		throw new RuntimeException("Error while getting state", e);
	}
}
 

@Override
@Deprecated
public <T, ACC> FoldingState<T, ACC> getFoldingState(FoldingStateDescriptor<T, ACC> stateProperties) {
	if (!stateRegistrationAllowed) {
		throw new RuntimeException(REGISTRATION_EXCEPTION_MSG);
	}

	registeredDescriptors.add(stateProperties);
	return keyedStateStore.getFoldingState(stateProperties);
}
 

@Override
@PublicEvolving
@Deprecated
public <T, ACC> FoldingState<T, ACC> getFoldingState(FoldingStateDescriptor<T, ACC> stateProperties) {
	throw new UnsupportedOperationException(
			"This state is only accessible by functions executed on a KeyedStream");
}
 

@Override
void updateInternal(@Nonnull FoldingState<Integer, Long> state, Integer update) throws Exception {
	state.add(update);
}
 

@Override
public <T, A> FoldingState<T, A> getFoldingState(FoldingStateDescriptor<T, A> stateProperties) {
	throw new UnsupportedOperationException("Per-window state is not allowed when using merging windows.");
}
 

@Override
public <T, ACC> FoldingState<T, ACC> getFoldingState(FoldingStateDescriptor<T, ACC> stateProperties) {
	KeyedStateStore keyedStateStore = checkPreconditionsAndGetKeyedStateStore(stateProperties);
	stateProperties.initializeSerializerUnlessSet(getExecutionConfig());
	return keyedStateStore.getFoldingState(stateProperties);
}
 

@Override
public <T, ACC> FoldingState<T, ACC> getFoldingState(FoldingStateDescriptor<T, ACC> stateProperties) {
	throw new UnsupportedOperationException("State is not supported in rich async functions.");
}
 

@Override
public <T, A> FoldingState<T, A> getFoldingState(FoldingStateDescriptor<T, A> stateProperties) {
	throw new UnsupportedOperationException("Per-window state is not allowed when using merging windows.");
}
 

@Override
public <T, ACC> FoldingState<T, ACC> getFoldingState(
    FoldingStateDescriptor<T, ACC> stateProperties) {
  throw new UnsupportedOperationException();
}
 

@Override
public <T, ACC> FoldingState<T, ACC> getFoldingState(
    FoldingStateDescriptor<T, ACC> stateProperties) {
  throw new UnsupportedOperationException();
}
 

@Override
public <T, ACC> FoldingState<T, ACC> getFoldingState(FoldingStateDescriptor<T, ACC> stateProperties) {
	throw new UnsupportedOperationException();
}
 

@Override
Long getInternal(@Nonnull FoldingState<Integer, Long> state) throws Exception {
	return state.get();
}
 

@Override
void updateInternal(@Nonnull FoldingState<Integer, Long> state, Integer update) throws Exception {
	state.add(update);
}
 

@Override
Long getInternal(@Nonnull FoldingState<Integer, Long> state) throws Exception {
	return state.get();
}
 

@Override
public <T, ACC> FoldingState<T, ACC> getFoldingState(FoldingStateDescriptor<T, ACC> stateProperties) {
	throw new UnsupportedOperationException();
}
 

@Override
public <T, ACC> FoldingState<T, ACC> getFoldingState(final FoldingStateDescriptor<T, ACC> stateProperties) {
	throw new UnsupportedOperationException("State is not supported.");
}
 

@Override
public <T, A> FoldingState<T, A> getFoldingState(FoldingStateDescriptor<T, A> stateProperties) {
	throw new UnsupportedOperationException("Per-window state is not allowed when using merging windows.");
}
 

@Override
public <T, ACC> FoldingState<T, ACC> getFoldingState(FoldingStateDescriptor<T, ACC> stateProperties) {
	throw new UnsupportedOperationException("State is not supported in rich async functions.");
}
 

@Override
public <T, ACC> FoldingState<T, ACC> getFoldingState(FoldingStateDescriptor<T, ACC> stateProperties) {
	KeyedStateStore keyedStateStore = checkPreconditionsAndGetKeyedStateStore(stateProperties);
	stateProperties.initializeSerializerUnlessSet(getExecutionConfig());
	return keyedStateStore.getFoldingState(stateProperties);
}
 

@Override
void updateInternal(@Nonnull FoldingState<Integer, Long> state, Integer update) throws Exception {
	state.add(update);
}
 

@Override
Long getInternal(@Nonnull FoldingState<Integer, Long> state) throws Exception {
	return state.get();
}
 

@Override
public <T, ACC> FoldingState<T, ACC> getFoldingState(FoldingStateDescriptor<T, ACC> stateProperties) {
	throw new UnsupportedOperationException();
}
 

@Override
public <T, ACC> FoldingState<T, ACC> getFoldingState(final FoldingStateDescriptor<T, ACC> stateProperties) {
	throw new UnsupportedOperationException("State is not supported.");
}
 

/**
 * Gets a handle to the system's key/value folding state. This state is similar to the state
 * accessed via {@link #getState(ValueStateDescriptor)}, but is optimized for state that
 * aggregates values with different types.
 *
 * <p>This state is only accessible if the function is executed on a KeyedStream.
 *
 * <pre>{@code
 * 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());
 *     }
 * });
 *
 * }</pre>
 *
 * @param stateProperties The descriptor defining the properties of the stats.
 *
 * @param <T> Type of the values folded in the other state
 * @param <ACC> Type of the value in the state
 *
 * @return The partitioned state object.
 *
 * @throws UnsupportedOperationException Thrown, if no partitioned state is available for the
 *                                       function (function is not part of a KeyedStream).
 *
 * @deprecated will be removed in a future version in favor of {@link AggregatingState}
 */
@PublicEvolving
@Deprecated
<T, ACC> FoldingState<T, ACC> getFoldingState(FoldingStateDescriptor<T, ACC> stateProperties);