@Override public TypeSerializerSchemaCompatibility<T> resolveSchemaCompatibility(TypeSerializer<T> newSerializer) { // if there is no configuration snapshot to check against, // then we can only assume that the new serializer is compatible as is return TypeSerializerSchemaCompatibility.compatibleAsIs(); }
@Override public TypeSerializerSchemaCompatibility<T> resolveSchemaCompatibility(TypeSerializer<T> newSerializer) { return newSerializer.getClass() == serializerSupplier.get().getClass() ? TypeSerializerSchemaCompatibility.compatibleAsIs() : TypeSerializerSchemaCompatibility.incompatible(); }
@Override public TypeSerializerSchemaCompatibility<T> resolveSchemaCompatibility( TypeSerializer<T> newSerializer) { // in prior versions, the compatibility check was in the serializer itself, so we // delegate this call to the serializer. final CompatibilityResult<T> compatibility = newSerializer.ensureCompatibility(this); return compatibility.isRequiresMigration() ? TypeSerializerSchemaCompatibility.incompatible() : TypeSerializerSchemaCompatibility.compatibleAsIs(); } }
/** * Resolves writer/reader schema compatibly. * * <p>Checks whenever a new version of a schema (reader) can read values serialized with the old schema (writer). * If the schemas are compatible according to {@code Avro} schema resolution rules * (@see <a href="https://avro.apache.org/docs/current/spec.html#Schema+Resolution">Schema Resolution</a>). */ @VisibleForTesting static <T> TypeSerializerSchemaCompatibility<T> resolveSchemaCompatibility( Schema writerSchema, Schema readerSchema) { if (Objects.equals(writerSchema, readerSchema)) { return TypeSerializerSchemaCompatibility.compatibleAsIs(); } final SchemaPairCompatibility compatibility = SchemaCompatibility.checkReaderWriterCompatibility(readerSchema, writerSchema); return avroCompatibilityToFlinkCompatibility(compatibility); }
@Override public TypeSerializerSchemaCompatibility<Long> resolveSchemaCompatibility(TypeSerializer<Long> newSerializer) { return (newSerializer instanceof TestSerializer) ? TypeSerializerSchemaCompatibility.compatibleAsIs() : TypeSerializerSchemaCompatibility.incompatible(); }
public TestSpecification<T> withNewSerializerProvider(Supplier<? extends TypeSerializer<T>> serializerProvider) { return withNewSerializerProvider(serializerProvider, TypeSerializerSchemaCompatibility.compatibleAsIs()); }
@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.compatibleAsIs();
return TypeSerializerSchemaCompatibility.compatibleAsIs();
@Override public TypeSerializerSchemaCompatibility<T> resolveSchemaCompatibility(TypeSerializer<T> newSerializer) { // if there is no configuration snapshot to check against, // then we can only assume that the new serializer is compatible as is return TypeSerializerSchemaCompatibility.compatibleAsIs(); }
@Override public TypeSerializerSchemaCompatibility<T> resolveSchemaCompatibility(TypeSerializer<T> newSerializer) { checkState(serializerClass != null); return newSerializer.getClass() == serializerClass ? TypeSerializerSchemaCompatibility.compatibleAsIs() : TypeSerializerSchemaCompatibility.incompatible(); }
@Override public TypeSerializerSchemaCompatibility<T> resolveSchemaCompatibility( TypeSerializer<T> newSerializer) { // in prior versions, the compatibility check was in the serializer itself, so we // delegate this call to the serializer. final CompatibilityResult<T> compatibility = newSerializer.ensureCompatibility(this); return compatibility.isRequiresMigration() ? TypeSerializerSchemaCompatibility.incompatible() : TypeSerializerSchemaCompatibility.compatibleAsIs(); } }
@Override public TypeSerializerSchemaCompatibility<ArrayList<T>> resolveSchemaCompatibility(TypeSerializer<ArrayList<T>> newSerializer) { checkState(nestedElementSerializerSnapshot != null); if (newSerializer instanceof ArrayListSerializer) { ArrayListSerializer<T> serializer = (ArrayListSerializer<T>) newSerializer; return nestedElementSerializerSnapshot.resolveCompatibilityWithNested( TypeSerializerSchemaCompatibility.compatibleAsIs(), serializer.getElementSerializer()); } else { return TypeSerializerSchemaCompatibility.incompatible(); } }
@Override public TypeSerializerSchemaCompatibility<ListView<T>> resolveSchemaCompatibility(TypeSerializer<ListView<T>> newSerializer) { checkState(nestedListSerializerSnapshot != null); if (newSerializer instanceof ListViewSerializer) { ListViewSerializer<T> serializer = (ListViewSerializer<T>) newSerializer; return nestedListSerializerSnapshot.resolveCompatibilityWithNested( TypeSerializerSchemaCompatibility.compatibleAsIs(), serializer.getListSerializer()); } else { return TypeSerializerSchemaCompatibility.incompatible(); } }
@Override public TypeSerializerSchemaCompatibility<List<T>> resolveSchemaCompatibility(TypeSerializer<List<T>> newSerializer) { checkState(nestedElementSerializerSnapshot != null); if (newSerializer instanceof ListSerializer) { ListSerializer<T> serializer = (ListSerializer<T>) newSerializer; return nestedElementSerializerSnapshot.resolveCompatibilityWithNested( TypeSerializerSchemaCompatibility.compatibleAsIs(), serializer.getElementSerializer()); } else { return TypeSerializerSchemaCompatibility.incompatible(); } }
@Override public TypeSerializerSchemaCompatibility<Lockable<E>> resolveSchemaCompatibility(TypeSerializer<Lockable<E>> newSerializer) { checkState(nestedElementSerializerSnapshot != null); if (newSerializer instanceof Lockable.LockableTypeSerializer) { Lockable.LockableTypeSerializer<E> serializer = (Lockable.LockableTypeSerializer<E>) newSerializer; return nestedElementSerializerSnapshot.resolveCompatibilityWithNested( TypeSerializerSchemaCompatibility.compatibleAsIs(), serializer.getElementSerializer()); } else { return TypeSerializerSchemaCompatibility.incompatible(); } }
@Override public TypeSerializerSchemaCompatibility<MapView<K, V>> resolveSchemaCompatibility( TypeSerializer<MapView<K, V>> newSerializer) { checkState(nestedMapSerializerSnapshot != null); if (newSerializer instanceof MapViewSerializer) { MapViewSerializer<K, V> serializer = (MapViewSerializer<K, V>) newSerializer; return nestedMapSerializerSnapshot.resolveCompatibilityWithNested( TypeSerializerSchemaCompatibility.compatibleAsIs(), serializer.getMapSerializer()); } else { return TypeSerializerSchemaCompatibility.incompatible(); } }
@Override public TypeSerializerSchemaCompatibility<ArrayList<T>> resolveSchemaCompatibility(TypeSerializer<ArrayList<T>> newSerializer) { checkState(nestedElementSerializerSnapshot != null); if (newSerializer instanceof ArrayListSerializer) { ArrayListSerializer<T> serializer = (ArrayListSerializer<T>) newSerializer; return nestedElementSerializerSnapshot.resolveCompatibilityWithNested( TypeSerializerSchemaCompatibility.compatibleAsIs(), serializer.getElementSerializer()); } else { return TypeSerializerSchemaCompatibility.incompatible(); } }
@Override public TypeSerializerSchemaCompatibility<Lockable<E>> resolveSchemaCompatibility(TypeSerializer<Lockable<E>> newSerializer) { checkState(nestedElementSerializerSnapshot != null); if (newSerializer instanceof Lockable.LockableTypeSerializer) { Lockable.LockableTypeSerializer<E> serializer = (Lockable.LockableTypeSerializer<E>) newSerializer; return nestedElementSerializerSnapshot.resolveCompatibilityWithNested( TypeSerializerSchemaCompatibility.compatibleAsIs(), serializer.getElementSerializer()); } else { return TypeSerializerSchemaCompatibility.incompatible(); } }
@Override public TypeSerializerSchemaCompatibility<Map<K, V>> resolveSchemaCompatibility(TypeSerializer<Map<K, V>> newSerializer) { checkState(nestedKeyValueSerializerSnapshot != null); if (newSerializer instanceof MapSerializer) { MapSerializer<K, V> serializer = (MapSerializer<K, V>) newSerializer; return nestedKeyValueSerializerSnapshot.resolveCompatibilityWithNested( TypeSerializerSchemaCompatibility.compatibleAsIs(), serializer.getKeySerializer(), serializer.getValueSerializer()); } else { return TypeSerializerSchemaCompatibility.incompatible(); } }