Java Code Examples for org.apache.flink.api.common.typeutils.TypeSerializerSchemaCompatibility#compatibleAsIs()

@Override
public TypeSerializerSchemaCompatibility<MapData> resolveSchemaCompatibility(TypeSerializer<MapData> newSerializer) {
	if (!(newSerializer instanceof MapDataSerializer)) {
		return TypeSerializerSchemaCompatibility.incompatible();
	}

	MapDataSerializer newBaseMapSerializer = (MapDataSerializer) newSerializer;
	if (!previousKeyType.equals(newBaseMapSerializer.keyType) ||
		!previousValueType.equals(newBaseMapSerializer.valueType) ||
		!previousKeySerializer.equals(newBaseMapSerializer.keySerializer) ||
		!previousValueSerializer.equals(newBaseMapSerializer.valueSerializer)) {
		return TypeSerializerSchemaCompatibility.incompatible();
	} else {
		return TypeSerializerSchemaCompatibility.compatibleAsIs();
	}
}
 

@Override
public TypeSerializerSchemaCompatibility<MapData> resolveSchemaCompatibility(TypeSerializer<MapData> newSerializer) {
	if (!(newSerializer instanceof MapDataSerializer)) {
		return TypeSerializerSchemaCompatibility.incompatible();
	}

	MapDataSerializer newMapDataSerializer = (MapDataSerializer) newSerializer;
	if (!previousKeyType.equals(newMapDataSerializer.keyType) ||
		!previousValueType.equals(newMapDataSerializer.valueType) ||
		!previousKeySerializer.equals(newMapDataSerializer.keyTypeSerializer) ||
		!previousValueSerializer.equals(newMapDataSerializer.valueTypeSerializer)) {
		return TypeSerializerSchemaCompatibility.incompatible();
	} else {
		return TypeSerializerSchemaCompatibility.compatibleAsIs();
	}
}
 

@Override
public TypeSerializerSchemaCompatibility<TestType> resolveSchemaCompatibility(TypeSerializer<TestType> newSerializer) {
	if (newSerializer instanceof TestType.V2TestTypeSerializer) {
		return TypeSerializerSchemaCompatibility.compatibleAsIs();
	} else if (newSerializer instanceof TestType.ReconfigurationRequiringTestTypeSerializer) {
		// we mimic the reconfiguration by just re-instantiating the correct serializer
		return TypeSerializerSchemaCompatibility.compatibleWithReconfiguredSerializer(new TestType.V2TestTypeSerializer());
	} else if (
		// migrating from V2 -> V1 is not supported
		newSerializer instanceof TestType.V1TestTypeSerializer
			|| newSerializer instanceof TestType.IncompatibleTestTypeSerializer) {

		return TypeSerializerSchemaCompatibility.incompatible();
	} else {
		throw new IllegalStateException("Unknown serializer class for TestType.");
	}
}
 

@Override
public TypeSerializerSchemaCompatibility<TestType> resolveSchemaCompatibility(TypeSerializer<TestType> newSerializer) {
	if (newSerializer instanceof TestType.V1TestTypeSerializer) {
		return TypeSerializerSchemaCompatibility.compatibleAsIs();
	} else if (newSerializer instanceof TestType.V2TestTypeSerializer) {
		return TypeSerializerSchemaCompatibility.compatibleAfterMigration();
	} else if (newSerializer instanceof TestType.ReconfigurationRequiringTestTypeSerializer) {
		// we mimic the reconfiguration by just re-instantiating the correct serializer
		return TypeSerializerSchemaCompatibility.compatibleWithReconfiguredSerializer(new TestType.V1TestTypeSerializer());
	} else if (newSerializer instanceof TestType.IncompatibleTestTypeSerializer) {
		return TypeSerializerSchemaCompatibility.incompatible();
	} else {
		throw new IllegalStateException("Unknown serializer class for TestType.");
	}
}
 

@Override
public TypeSerializerSchemaCompatibility<T> resolveSchemaCompatibility(TypeSerializer<T> newSerializer) {
	if (!(newSerializer instanceof EnumSerializer)) {
		return TypeSerializerSchemaCompatibility.incompatible();
	}

	EnumSerializer<T> newEnumSerializer = (EnumSerializer<T>) newSerializer;
	if (!enumClass.equals(newEnumSerializer.enumClass)) {
		return TypeSerializerSchemaCompatibility.incompatible();
	}

	T[] currentEnums = enumClass.getEnumConstants();

	if (Arrays.equals(previousEnums, currentEnums)) {
		return TypeSerializerSchemaCompatibility.compatibleAsIs();
	}

	Set<T> reconfiguredEnumSet = new LinkedHashSet<>(Arrays.asList(previousEnums));
	reconfiguredEnumSet.addAll(Arrays.asList(currentEnums));

	@SuppressWarnings("unchecked")
	T[] reconfiguredEnums = reconfiguredEnumSet.toArray(
			(T[]) Array.newInstance(enumClass, reconfiguredEnumSet.size()));

	EnumSerializer<T> reconfiguredSerializer = new EnumSerializer<>(
			enumClass,
			reconfiguredEnums);
	return TypeSerializerSchemaCompatibility.compatibleWithReconfiguredSerializer(
			reconfiguredSerializer);
}
 

@Override
public TypeSerializerSchemaCompatibility<TimestampData> resolveSchemaCompatibility(TypeSerializer<TimestampData> newSerializer) {
	if (!(newSerializer instanceof TimestampDataSerializer)) {
		return TypeSerializerSchemaCompatibility.incompatible();
	}

	TimestampDataSerializer timestampDataSerializer = (TimestampDataSerializer) newSerializer;
	if (previousPrecision != timestampDataSerializer.precision) {
		return TypeSerializerSchemaCompatibility.incompatible();
	} else {
		return TypeSerializerSchemaCompatibility.compatibleAsIs();
	}
}
 

@Override
public TypeSerializerSchemaCompatibility<TestElement> resolveSchemaCompatibility(TypeSerializer<TestElement> newSerializer) {
	if (!(newSerializer instanceof TestElementSerializer)) {
		return TypeSerializerSchemaCompatibility.incompatible();
	}

	TestElementSerializer testElementSerializer = (TestElementSerializer) newSerializer;
	return (revision <= testElementSerializer.getRevision())
		? TypeSerializerSchemaCompatibility.compatibleAsIs()
		: TypeSerializerSchemaCompatibility.incompatible();
}
 

@Override
public TypeSerializerSchemaCompatibility<Message> resolveSchemaCompatibility(
    TypeSerializer<Message> typeSerializer) {
  if (!(typeSerializer instanceof MessageTypeSerializer)) {
    return TypeSerializerSchemaCompatibility.incompatible();
  }
  MessageTypeSerializer casted = (MessageTypeSerializer) typeSerializer;
  if (casted.messageFactoryType == messageFactoryType) {
    return TypeSerializerSchemaCompatibility.compatibleAsIs();
  }
  return TypeSerializerSchemaCompatibility.incompatible();
}
 

/**
 * Check schema compatibility with the new serializer.
 *
 * <p>This check is very simplistic, that just compares the two typeClasses, but the {@link
 * ProtobufSerializerSnapshot} has much more information to be used for compatibility resolution.
 * We make sure to store this information first, and implement a more robust schema resolution
 * logic in the future.
 */
private TypeSerializerSchemaCompatibility<M> resolveSchemaCompatibility(
    ProtobufTypeSerializer<?> newSerializer) {
  Class<?> otherTypeClass = newSerializer.getTypeClass();
  if (otherTypeClass == typeClass) {
    return TypeSerializerSchemaCompatibility.compatibleAsIs();
  }
  return TypeSerializerSchemaCompatibility.incompatible();
}
 

@Override
public TypeSerializerSchemaCompatibility<SortedMap<K, V>> resolveSchemaCompatibility(
		TypeSerializer<SortedMap<K, V>> newSerializer) {
	if (!(newSerializer instanceof SortedMapSerializer)) {
		return TypeSerializerSchemaCompatibility.incompatible();
	}
	SortedMapSerializer newSortedMapSerializer = (SortedMapSerializer) newSerializer;
	if (!comparator.equals(newSortedMapSerializer.getComparator())) {
		return TypeSerializerSchemaCompatibility.incompatible();
	} else {
		return TypeSerializerSchemaCompatibility.compatibleAsIs();
	}
}
 

@Override
public TypeSerializerSchemaCompatibility<TestType> resolveSchemaCompatibility(TypeSerializer<TestType> newSerializer) {
	if (newSerializer instanceof TestType.V1TestTypeSerializer) {
		return TypeSerializerSchemaCompatibility.compatibleAsIs();
	} else if (newSerializer instanceof TestType.V2TestTypeSerializer) {
		return TypeSerializerSchemaCompatibility.compatibleAfterMigration();
	} else if (newSerializer instanceof TestType.ReconfigurationRequiringTestTypeSerializer) {
		// we mimic the reconfiguration by just re-instantiating the correct serializer
		return TypeSerializerSchemaCompatibility.compatibleWithReconfiguredSerializer(new TestType.V1TestTypeSerializer());
	} else if (newSerializer instanceof TestType.IncompatibleTestTypeSerializer) {
		return TypeSerializerSchemaCompatibility.incompatible();
	} else {
		throw new IllegalStateException("Unknown serializer class for TestType.");
	}
}
 

@Override
public TypeSerializerSchemaCompatibility<TestElement> resolveSchemaCompatibility(TypeSerializer<TestElement> newSerializer) {
	if (!(newSerializer instanceof TestElementSerializer)) {
		return TypeSerializerSchemaCompatibility.incompatible();
	}

	TestElementSerializer testElementSerializer = (TestElementSerializer) newSerializer;
	return (revision <= testElementSerializer.getRevision())
		? TypeSerializerSchemaCompatibility.compatibleAsIs()
		: TypeSerializerSchemaCompatibility.incompatible();
}
 

@Override
public TypeSerializerSchemaCompatibility<Timestamp> resolveSchemaCompatibility(TypeSerializer<Timestamp> newSerializer) {
	if (!(newSerializer instanceof TimestampSerializer)) {
		return TypeSerializerSchemaCompatibility.incompatible();
	}

	TimestampSerializer timestampSerializer = (TimestampSerializer) newSerializer;
	if (previousPrecision != timestampSerializer.precision) {
		return TypeSerializerSchemaCompatibility.incompatible();
	} else {
		return TypeSerializerSchemaCompatibility.compatibleAsIs();
	}
}
 

@Override
public TypeSerializerSchemaCompatibility<T> resolveSchemaCompatibility(TypeSerializer<T> newSerializer) {
	if (newSerializer.getClass() != PojoSerializer.class) {
		return TypeSerializerSchemaCompatibility.incompatible();
	}

	final PojoSerializer<T> newPojoSerializer = (PojoSerializer<T>) newSerializer;

	final Class<T> previousPojoClass = snapshotData.getPojoClass();
	final LinkedOptionalMap<Field, TypeSerializerSnapshot<?>> fieldSerializerSnapshots = snapshotData.getFieldSerializerSnapshots();
	final LinkedOptionalMap<Class<?>, TypeSerializerSnapshot<?>> registeredSubclassSerializerSnapshots = snapshotData.getRegisteredSubclassSerializerSnapshots();
	final LinkedOptionalMap<Class<?>, TypeSerializerSnapshot<?>> nonRegisteredSubclassSerializerSnapshots = snapshotData.getNonRegisteredSubclassSerializerSnapshots();

	if (previousPojoClass != newPojoSerializer.getPojoClass()) {
		return TypeSerializerSchemaCompatibility.incompatible();
	}

	if (registeredSubclassSerializerSnapshots.hasAbsentKeysOrValues()) {
		return TypeSerializerSchemaCompatibility.incompatible();
	}

	if (nonRegisteredSubclassSerializerSnapshots.hasAbsentKeysOrValues()) {
		return TypeSerializerSchemaCompatibility.incompatible();
	}

	final IntermediateCompatibilityResult<T> preExistingFieldSerializersCompatibility =
		getCompatibilityOfPreExistingFields(newPojoSerializer, fieldSerializerSnapshots);

	if (preExistingFieldSerializersCompatibility.isIncompatible()) {
		return TypeSerializerSchemaCompatibility.incompatible();
	}

	final IntermediateCompatibilityResult<T> preExistingRegistrationsCompatibility =
		getCompatibilityOfPreExistingRegisteredSubclasses(newPojoSerializer, registeredSubclassSerializerSnapshots);

	if (preExistingRegistrationsCompatibility.isIncompatible()) {
		return TypeSerializerSchemaCompatibility.incompatible();
	}

	if (newPojoSerializerIsCompatibleAfterMigration(
			newPojoSerializer,
			preExistingFieldSerializersCompatibility,
			preExistingRegistrationsCompatibility,
			fieldSerializerSnapshots)) {

		return TypeSerializerSchemaCompatibility.compatibleAfterMigration();
	}

	if (newPojoSerializerIsCompatibleWithReconfiguredSerializer(
			newPojoSerializer,
			preExistingFieldSerializersCompatibility,
			preExistingRegistrationsCompatibility,
			registeredSubclassSerializerSnapshots,
			nonRegisteredSubclassSerializerSnapshots)) {

		return TypeSerializerSchemaCompatibility.compatibleWithReconfiguredSerializer(
			constructReconfiguredPojoSerializer(
				newPojoSerializer,
				preExistingFieldSerializersCompatibility,
				registeredSubclassSerializerSnapshots,
				preExistingRegistrationsCompatibility,
				nonRegisteredSubclassSerializerSnapshots));
	}

	return TypeSerializerSchemaCompatibility.compatibleAsIs();
}
 

public static SchemaCompatibilityTestingSnapshot thatIsCompatibleWithNextSerializer(String tokenForEqualityChecks) {
	return new SchemaCompatibilityTestingSnapshot(tokenForEqualityChecks, unused -> TypeSerializerSchemaCompatibility.compatibleAsIs());
}
 

public static SchemaCompatibilityTestingSnapshot thatIsCompatibleWithNextSerializer(String tokenForEqualityChecks) {
	return new SchemaCompatibilityTestingSnapshot(tokenForEqualityChecks, unused -> TypeSerializerSchemaCompatibility.compatibleAsIs());
}
 

@Override
public TypeSerializerSchemaCompatibility<VoidNamespace>
resolveSchemaCompatibility(TypeSerializer<VoidNamespace> newSerializer) {
	return TypeSerializerSchemaCompatibility.compatibleAsIs();
}
 

@Override
public TypeSerializerSchemaCompatibility<VoidNamespace>
resolveSchemaCompatibility(TypeSerializer<VoidNamespace> newSerializer) {
	return TypeSerializerSchemaCompatibility.compatibleAsIs();
}
 

public static SchemaCompatibilityTestingSnapshot thatIsCompatibleWithNextSerializer(String tokenForEqualityChecks) {
	return new SchemaCompatibilityTestingSnapshot(tokenForEqualityChecks, unused -> TypeSerializerSchemaCompatibility.compatibleAsIs());
}
 

@Override
public TypeSerializerSchemaCompatibility<Long> resolveSchemaCompatibility(TypeSerializer<Long> newSerializer) {
	return (newSerializer instanceof TestSerializer)
		? TypeSerializerSchemaCompatibility.compatibleAsIs()
		: TypeSerializerSchemaCompatibility.incompatible();
}