@Override public TypeSerializerSchemaCompatibility<T> resolveSchemaCompatibility(TypeSerializer<T> newSerializer) { return newSerializer.getClass() == serializerSupplier.get().getClass() ? TypeSerializerSchemaCompatibility.compatibleAsIs() : TypeSerializerSchemaCompatibility.incompatible(); }
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<T> resolveSchemaCompatibility(TypeSerializer<T> newSerializer) { if (!(newSerializer instanceof AvroSerializer)) { return TypeSerializerSchemaCompatibility.incompatible(); } AvroSerializer<?> newAvroSerializer = (AvroSerializer<?>) newSerializer; return resolveSchemaCompatibility(schema, newAvroSerializer.getAvroSchema()); }
@Internal TypeSerializerSchemaCompatibility<T> internalResolveSchemaCompatibility( TypeSerializer<T> newSerializer, TypeSerializerSnapshot<?>[] snapshots) { if (newSerializer.getClass() != correspondingSerializerClass) { return TypeSerializerSchemaCompatibility.incompatible(); } S castedNewSerializer = correspondingSerializerClass.cast(newSerializer); // check that outer configuration is compatible; if not, short circuit result if (!isOuterSnapshotCompatible(castedNewSerializer)) { return TypeSerializerSchemaCompatibility.incompatible(); } return constructFinalSchemaCompatibilityResult( getNestedSerializers(castedNewSerializer), snapshots); }
@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<Long> resolveSchemaCompatibility(TypeSerializer<Long> newSerializer) { return (newSerializer instanceof TestSerializer) ? TypeSerializerSchemaCompatibility.compatibleAsIs() : TypeSerializerSchemaCompatibility.incompatible(); }
@Override public TypeSerializerSchemaCompatibility<C[]> resolveSchemaCompatibility(TypeSerializer<C[]> newSerializer) { checkState(nestedSnapshot != null); if (!(newSerializer instanceof GenericArraySerializer)) { return TypeSerializerSchemaCompatibility.incompatible(); } // delegate to the new snapshot class return CompositeTypeSerializerUtil.delegateCompatibilityCheckToNewSnapshot( newSerializer, new GenericArraySerializerSnapshot<>(componentClass), nestedSnapshot.getNestedSerializerSnapshots()); } }
@Override public TypeSerializerSchemaCompatibility<Either<L, R>> resolveSchemaCompatibility( TypeSerializer<Either<L, R>> newSerializer) { checkState(nestedSnapshot != null); if (newSerializer instanceof EitherSerializer) { // delegate compatibility check to the new snapshot class return CompositeTypeSerializerUtil.delegateCompatibilityCheckToNewSnapshot( newSerializer, new JavaEitherSerializerSnapshot<>(), nestedSnapshot.getNestedSerializerSnapshots()); } else { return TypeSerializerSchemaCompatibility.incompatible(); } } }
return TypeSerializerSchemaCompatibility.incompatible(); 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); }
return TypeSerializerSchemaCompatibility.incompatible();
@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) { if (!(newSerializer instanceof AvroSerializer)) { return TypeSerializerSchemaCompatibility.incompatible(); } AvroSerializer<?> newAvroSerializer = (AvroSerializer<?>) newSerializer; return resolveSchemaCompatibility(schema, newAvroSerializer.getAvroSchema()); }
@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<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<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<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<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(); } }