[
https://issues.apache.org/jira/browse/AVRO-3974?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
mknaw updated AVRO-3974:
------------------------
Description:
A schema with a field that is a ref to a different schema is incompatible with
itself, per `SchemaCompatibility`:
{code:java}
use apache_avro::{schema_compatibility::SchemaCompatibility, Schema};
fn main() {
let schema_strs = vec![
r#"{
"type": "record",
"name": "Child",
"namespace": "avro",
"fields": [
{
"name": "val",
"type": "int"
}
]
}
"#,
r#"{
"type": "record",
"name": "Parent",
"namespace": "avro",
"fields": [
{
"name": "child",
"type": "avro.Child"
}
]
}
"#,
];
let schemas = Schema::parse_list(&schema_strs).unwrap();
if let Err(e) = SchemaCompatibility::can_read(
&schemas[1],
&schemas[1]
) {
eprintln!("{}", e);
}
} {code}
Here it is somewhat ambiguous to me how the fix should look. of course the
simplest is just to verify the names are the same, and maybe if doing compat
checks across a whole batch of schemas then check for incompatibilities when
checking the referenced schemas themselves. But I'm not sure this is quite
satisfactory - imagine having a complex field that was previously defined
inline, but now want to reuse it across multiple schemas. In this case, it does
not seem like replacing the inline definition with a ref should be
incompatible. So, it seems that some sort of "recursive flattening" of the
schema prior to compat check would be the ideal fix.
was:
A schema with a field that is a ref to a different schema is incompatible with
itself, per `SchemaCompatibility`:
{code:java}
use apache_avro::{schema_compatibility::SchemaCompatibility, Schema};fn main() {
let schema_strs = vec![
r#"{
"type": "record",
"name": "Child",
"namespace": "avro",
"fields": [
{
"name": "val",
"type": "int"
}
]
}
"#,
r#"{
"type": "record",
"name": "Parent",
"namespace": "avro",
"fields": [
{
"name": "child",
"type": "avro.Child"
}
]
}
"#,
];
let schemas = Schema::parse_list(&schema_strs).unwrap();
if let Err(e) = SchemaCompatibility::can_read(
&schemas[1],
&schemas[1]
) {
eprintln!("{}", e);
}
} {code}
Here it is somewhat ambiguous to me how the fix should look. of course the
simplest is just to verify the names are the same, and maybe if doing compat
checks across a whole batch of schemas then check for incompatibilities when
checking the referenced schemas themselves. But I'm not sure this is quite
satisfactory - imagine having a complex field that was previously defined
inline, but now want to reuse it across multiple schemas. In this case, it does
not seem like replacing the inline definition with a ref should be
incompatible. So, it seems that some sort of "recursive flattening" of the
schema prior to compat check would be the ideal fix.
> [Rust] incorrect compatibility checks with ref fields
> -----------------------------------------------------
>
> Key: AVRO-3974
> URL: https://issues.apache.org/jira/browse/AVRO-3974
> Project: Apache Avro
> Issue Type: Bug
> Components: rust
> Reporter: mknaw
> Priority: Minor
> Labels: pull-request-available
>
> A schema with a field that is a ref to a different schema is incompatible
> with itself, per `SchemaCompatibility`:
> {code:java}
> use apache_avro::{schema_compatibility::SchemaCompatibility, Schema};
> fn main() {
> let schema_strs = vec![
> r#"{
> "type": "record",
> "name": "Child",
> "namespace": "avro",
> "fields": [
> {
> "name": "val",
> "type": "int"
> }
> ]
> }
> "#,
> r#"{
> "type": "record",
> "name": "Parent",
> "namespace": "avro",
> "fields": [
> {
> "name": "child",
> "type": "avro.Child"
> }
> ]
> }
> "#,
> ];
>
> let schemas = Schema::parse_list(&schema_strs).unwrap();
> if let Err(e) = SchemaCompatibility::can_read(
> &schemas[1],
> &schemas[1]
> ) {
> eprintln!("{}", e);
> }
> } {code}
>
> Here it is somewhat ambiguous to me how the fix should look. of course the
> simplest is just to verify the names are the same, and maybe if doing compat
> checks across a whole batch of schemas then check for incompatibilities when
> checking the referenced schemas themselves. But I'm not sure this is quite
> satisfactory - imagine having a complex field that was previously defined
> inline, but now want to reuse it across multiple schemas. In this case, it
> does not seem like replacing the inline definition with a ref should be
> incompatible. So, it seems that some sort of "recursive flattening" of the
> schema prior to compat check would be the ideal fix.
--
This message was sent by Atlassian Jira
(v8.20.10#820010)
