private static <T> TypeSerializerSchemaCompatibility<T> avroCompatibilityToFlinkCompatibility(SchemaPairCompatibility compatibility) { switch (compatibility.getType()) { case COMPATIBLE: { // The new serializer would be able to read data persisted with *this* serializer, therefore no migration // is required. return TypeSerializerSchemaCompatibility.compatibleAfterMigration(); } case INCOMPATIBLE: { return TypeSerializerSchemaCompatibility.incompatible(); } case RECURSION_IN_PROGRESS: default: return TypeSerializerSchemaCompatibility.incompatible(); } }
@Override public TypeSerializerSchemaCompatibility<String> resolveSchemaCompatibility(TypeSerializer<String> newSerializer) { // checks the exact class instead of using instanceof; // this ensures that we get a new serializer, and not a ReconfiguredNestedSerializer or RestoredNestedSerializer if (newSerializer.getClass() == NestedSerializer.class) { switch (targetCompatibility) { case COMPATIBLE_AS_IS: return TypeSerializerSchemaCompatibility.compatibleAsIs(); case COMPATIBLE_AFTER_MIGRATION: return TypeSerializerSchemaCompatibility.compatibleAfterMigration(); case COMPATIBLE_WITH_RECONFIGURED_SERIALIZER: return TypeSerializerSchemaCompatibility.compatibleWithReconfiguredSerializer( new ReconfiguredNestedSerializer(targetCompatibility)); case INCOMPATIBLE: return TypeSerializerSchemaCompatibility.incompatible(); default: throw new IllegalStateException("Unexpected target compatibility."); } } throw new IllegalArgumentException("Expected the new serializer to be of class " + NestedSerializer.class); }
TypeSerializerSchemaCompatibility.compatibleAfterMigration() : TypeSerializerSchemaCompatibility.compatibleAsIs();
return TypeSerializerSchemaCompatibility.compatibleAfterMigration();
private static <T> TypeSerializerSchemaCompatibility<T> avroCompatibilityToFlinkCompatibility(SchemaPairCompatibility compatibility) { switch (compatibility.getType()) { case COMPATIBLE: { // The new serializer would be able to read data persisted with *this* serializer, therefore no migration // is required. return TypeSerializerSchemaCompatibility.compatibleAfterMigration(); } case INCOMPATIBLE: { return TypeSerializerSchemaCompatibility.incompatible(); } case RECURSION_IN_PROGRESS: default: return TypeSerializerSchemaCompatibility.incompatible(); } }
@SuppressWarnings("unchecked") private TypeSerializerSchemaCompatibility<Either<L, R>> checkJavaSerializerCompatibility( EitherSerializer<L, R> serializer) { TypeSerializer<L> leftSerializer = serializer.getLeftSerializer(); TypeSerializer<R> rightSerializer = serializer.getRightSerializer(); TypeSerializerSnapshot<L> leftSnapshot = (TypeSerializerSnapshot<L>) getNestedSerializersAndConfigs().get(0).f1; TypeSerializerSnapshot<R> rightSnapshot = (TypeSerializerSnapshot<R>) getNestedSerializersAndConfigs().get(1).f1; TypeSerializerSchemaCompatibility<?> leftCompatibility = leftSnapshot.resolveSchemaCompatibility(leftSerializer); TypeSerializerSchemaCompatibility<?> rightCompatibility = rightSnapshot.resolveSchemaCompatibility(rightSerializer); if (leftCompatibility.isCompatibleAsIs() && rightCompatibility.isCompatibleAsIs()) { return TypeSerializerSchemaCompatibility.compatibleAsIs(); } if (leftCompatibility.isCompatibleAfterMigration() && rightCompatibility.isCompatibleAfterMigration()) { return TypeSerializerSchemaCompatibility.compatibleAfterMigration(); } return TypeSerializerSchemaCompatibility.incompatible(); } }
/** * Resolves the compatibility of the nested serializer snapshots with the nested * serializers of the new outer serializer. */ public <T> TypeSerializerSchemaCompatibility<T> resolveCompatibilityWithNested( TypeSerializerSchemaCompatibility<?> outerCompatibility, TypeSerializer<?>... newNestedSerializers) { checkArgument(newNestedSerializers.length == nestedSnapshots.length, "Different number of new serializers and existing serializer configuration snapshots"); // compatibility of the outer serializer's format if (outerCompatibility.isIncompatible()) { return TypeSerializerSchemaCompatibility.incompatible(); } // check nested serializers for compatibility boolean nestedSerializerRequiresMigration = false; for (int i = 0; i < nestedSnapshots.length; i++) { TypeSerializerSchemaCompatibility<?> compatibility = resolveCompatibility(newNestedSerializers[i], nestedSnapshots[i]); if (compatibility.isIncompatible()) { return TypeSerializerSchemaCompatibility.incompatible(); } if (compatibility.isCompatibleAfterMigration()) { nestedSerializerRequiresMigration = true; } } return (nestedSerializerRequiresMigration || !outerCompatibility.isCompatibleAsIs()) ? TypeSerializerSchemaCompatibility.compatibleAfterMigration() : TypeSerializerSchemaCompatibility.compatibleAsIs(); }