You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@avro.apache.org by mg...@apache.org on 2026/01/27 13:25:15 UTC

(avro-rs) branch dont-allow-duplicating-names-from-known-schemata created (now 1abb1bc)

This is an automated email from the ASF dual-hosted git repository.

mgrigorov pushed a change to branch dont-allow-duplicating-names-from-known-schemata
in repository https://gitbox.apache.org/repos/asf/avro-rs.git


      at 1abb1bc  fix: Don't allow resolving a schema that is already known

This branch includes the following new commits:

     new 1abb1bc  fix: Don't allow resolving a schema that is already known

The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.



(avro-rs) 01/01: fix: Don't allow resolving a schema that is already known

Posted by mg...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

mgrigorov pushed a commit to branch dont-allow-duplicating-names-from-known-schemata
in repository https://gitbox.apache.org/repos/asf/avro-rs.git

commit 1abb1bc7e88a5bff8ff05c93bd611fb8fffe8520
Author: Martin Tzvetanov Grigorov <mg...@apache.org>
AuthorDate: Tue Jan 27 15:18:52 2026 +0200

    fix: Don't allow resolving a schema that is already known
    
    The `known_schemata` NamesRef is used to resolve schema references, i.e.
    if a schema ref is not referring to a schema that has been seen/defined
    earlier in the same schema definition (JSON) then we consult a collection
    of known (previously parsed) schemas.
    
    If a newly parsed schema is defined earlier then an AmbiguousSchemaDefinition error is returned.
    The same should be done when a newly parsed schema clashes with a schema
    with the very same name in `known_schemata`
---
 avro/src/schema/resolve.rs | 133 ++++++++++++++++++++++++++++++++-------------
 1 file changed, 96 insertions(+), 37 deletions(-)

diff --git a/avro/src/schema/resolve.rs b/avro/src/schema/resolve.rs
index e82b87d..7abd4f6 100644
--- a/avro/src/schema/resolve.rs
+++ b/avro/src/schema/resolve.rs
@@ -105,27 +105,30 @@ impl<'s> ResolvedSchema<'s> {
                 })
                 | Schema::Duration(FixedSchema { name, .. }) => {
                     let fully_qualified_name = name.fully_qualified_name(enclosing_namespace);
-                    if self
-                        .names_ref
-                        .insert(fully_qualified_name.clone(), schema)
-                        .is_some()
-                    {
+                    let is_duplicate = self.names_ref.contains_key(&fully_qualified_name)
+                        || known_schemata
+                            .as_ref()
+                            .map(|names| names.contains_key(&fully_qualified_name))
+                            .unwrap_or(false);
+                    if is_duplicate {
                         return Err(Details::AmbiguousSchemaDefinition(fully_qualified_name).into());
                     }
+                    self.names_ref.insert(fully_qualified_name.clone(), schema);
                 }
                 Schema::Record(RecordSchema { name, fields, .. }) => {
                     let fully_qualified_name = name.fully_qualified_name(enclosing_namespace);
-                    if self
-                        .names_ref
-                        .insert(fully_qualified_name.clone(), schema)
-                        .is_some()
-                    {
+                    let is_duplicate = self.names_ref.contains_key(&fully_qualified_name)
+                        || known_schemata
+                            .as_ref()
+                            .map(|names| names.contains_key(&fully_qualified_name))
+                            .unwrap_or(false);
+                    if is_duplicate {
                         return Err(Details::AmbiguousSchemaDefinition(fully_qualified_name).into());
-                    } else {
-                        let record_namespace = fully_qualified_name.namespace;
-                        for field in fields {
-                            self.resolve(vec![&field.schema], &record_namespace, known_schemata)?
-                        }
+                    }
+                    self.names_ref.insert(fully_qualified_name.clone(), schema);
+                    let record_namespace = fully_qualified_name.namespace;
+                    for field in fields {
+                        self.resolve(vec![&field.schema], &record_namespace, known_schemata)?
                     }
                 }
                 Schema::Ref { name } => {
@@ -266,9 +269,12 @@ pub fn resolve_names_with_schemata(
 
 #[cfg(test)]
 mod tests {
+    use std::collections::HashMap;
+
+    use super::{ResolvedOwnedSchema, ResolvedSchema};
     use crate::Schema;
-    use crate::schema::Name;
-    use crate::schema::resolve::{ResolvedOwnedSchema, ResolvedSchema};
+    use crate::error::Details;
+    use crate::schema::{Name, NamesRef};
     use apache_avro_test_helper::TestResult;
 
     #[test]
@@ -303,7 +309,7 @@ mod tests {
         }
         "#;
         let schema = Schema::parse_str(schema)?;
-        let rs = ResolvedSchema::try_from(&schema).expect("Schema didn't successfully parse");
+        let rs = ResolvedSchema::try_from(&schema)?;
         assert_eq!(rs.get_names().len(), 2);
         for s in &["space.record_name", "space.inner_record_name"] {
             assert!(rs.get_names().contains_key(&Name::new(s)?));
@@ -344,7 +350,7 @@ mod tests {
         }
         "#;
         let schema = Schema::parse_str(schema)?;
-        let rs = ResolvedSchema::try_from(&schema).expect("Schema didn't successfully parse");
+        let rs = ResolvedSchema::try_from(&schema)?;
         assert_eq!(rs.get_names().len(), 2);
         for s in &["space.record_name", "space.inner_record_name"] {
             assert!(rs.get_names().contains_key(&Name::new(s)?));
@@ -380,7 +386,7 @@ mod tests {
         }
         "#;
         let schema = Schema::parse_str(schema)?;
-        let rs = ResolvedSchema::try_from(&schema).expect("Schema didn't successfully parse");
+        let rs = ResolvedSchema::try_from(&schema)?;
         assert_eq!(rs.get_names().len(), 2);
         for s in &["space.record_name", "space.inner_enum_name"] {
             assert!(rs.get_names().contains_key(&Name::new(s)?));
@@ -416,7 +422,7 @@ mod tests {
         }
         "#;
         let schema = Schema::parse_str(schema)?;
-        let rs = ResolvedSchema::try_from(&schema).expect("Schema didn't successfully parse");
+        let rs = ResolvedSchema::try_from(&schema)?;
         assert_eq!(rs.get_names().len(), 2);
         for s in &["space.record_name", "space.inner_enum_name"] {
             assert!(rs.get_names().contains_key(&Name::new(s)?));
@@ -452,7 +458,7 @@ mod tests {
         }
         "#;
         let schema = Schema::parse_str(schema)?;
-        let rs = ResolvedSchema::try_from(&schema).expect("Schema didn't successfully parse");
+        let rs = ResolvedSchema::try_from(&schema)?;
         assert_eq!(rs.get_names().len(), 2);
         for s in &["space.record_name", "space.inner_fixed_name"] {
             assert!(rs.get_names().contains_key(&Name::new(s)?));
@@ -488,7 +494,7 @@ mod tests {
         }
         "#;
         let schema = Schema::parse_str(schema)?;
-        let rs = ResolvedSchema::try_from(&schema).expect("Schema didn't successfully parse");
+        let rs = ResolvedSchema::try_from(&schema)?;
         assert_eq!(rs.get_names().len(), 2);
         for s in &["space.record_name", "space.inner_fixed_name"] {
             assert!(rs.get_names().contains_key(&Name::new(s)?));
@@ -530,7 +536,7 @@ mod tests {
         }
         "#;
         let schema = Schema::parse_str(schema)?;
-        let rs = ResolvedSchema::try_from(&schema).expect("Schema didn't successfully parse");
+        let rs = ResolvedSchema::try_from(&schema)?;
         assert_eq!(rs.get_names().len(), 2);
         for s in &["space.record_name", "inner_space.inner_record_name"] {
             assert!(rs.get_names().contains_key(&Name::new(s)?));
@@ -567,7 +573,7 @@ mod tests {
         }
         "#;
         let schema = Schema::parse_str(schema)?;
-        let rs = ResolvedSchema::try_from(&schema).expect("Schema didn't successfully parse");
+        let rs = ResolvedSchema::try_from(&schema)?;
         assert_eq!(rs.get_names().len(), 2);
         for s in &["space.record_name", "inner_space.inner_enum_name"] {
             assert!(rs.get_names().contains_key(&Name::new(s)?));
@@ -604,7 +610,7 @@ mod tests {
         }
         "#;
         let schema = Schema::parse_str(schema)?;
-        let rs = ResolvedSchema::try_from(&schema).expect("Schema didn't successfully parse");
+        let rs = ResolvedSchema::try_from(&schema)?;
         assert_eq!(rs.get_names().len(), 2);
         for s in &["space.record_name", "inner_space.inner_fixed_name"] {
             assert!(rs.get_names().contains_key(&Name::new(s)?));
@@ -657,7 +663,7 @@ mod tests {
         }
         "#;
         let schema = Schema::parse_str(schema)?;
-        let rs = ResolvedSchema::try_from(&schema).expect("Schema didn't successfully parse");
+        let rs = ResolvedSchema::try_from(&schema)?;
         assert_eq!(rs.get_names().len(), 3);
         for s in &[
             "space.record_name",
@@ -715,7 +721,7 @@ mod tests {
         }
         "#;
         let schema = Schema::parse_str(schema)?;
-        let rs = ResolvedSchema::try_from(&schema).expect("Schema didn't successfully parse");
+        let rs = ResolvedSchema::try_from(&schema)?;
         assert_eq!(rs.get_names().len(), 3);
         for s in &[
             "space.record_name",
@@ -774,7 +780,7 @@ mod tests {
         }
         "#;
         let schema = Schema::parse_str(schema)?;
-        let rs = ResolvedSchema::try_from(&schema).expect("Schema didn't successfully parse");
+        let rs = ResolvedSchema::try_from(&schema)?;
         assert_eq!(rs.get_names().len(), 3);
         for s in &[
             "space.record_name",
@@ -819,7 +825,7 @@ mod tests {
         }
         "#;
         let schema = Schema::parse_str(schema)?;
-        let rs = ResolvedSchema::try_from(&schema).expect("Schema didn't successfully parse");
+        let rs = ResolvedSchema::try_from(&schema)?;
         assert_eq!(rs.get_names().len(), 2);
         for s in &["space.record_name", "space.in_array_record"] {
             assert!(rs.get_names().contains_key(&Name::new(s)?));
@@ -860,7 +866,7 @@ mod tests {
         }
         "#;
         let schema = Schema::parse_str(schema)?;
-        let rs = ResolvedSchema::try_from(&schema).expect("Schema didn't successfully parse");
+        let rs = ResolvedSchema::try_from(&schema)?;
         assert_eq!(rs.get_names().len(), 2);
         for s in &["space.record_name", "space.in_map_record"] {
             assert!(rs.get_names().contains_key(&Name::new(s)?));
@@ -897,7 +903,7 @@ mod tests {
         }
         "#;
         let schema = Schema::parse_str(schema)?;
-        let rs = ResolvedSchema::try_from(&schema).expect("Schema didn't successfully parse");
+        let rs = ResolvedSchema::try_from(&schema)?;
 
         // confirm we have expected 2 full-names
         assert_eq!(rs.get_names().len(), 2);
@@ -906,8 +912,8 @@ mod tests {
         }
 
         // convert Schema back to JSON string
-        let schema_str = serde_json::to_string(&schema).expect("test failed");
-        let _schema = Schema::parse_str(&schema_str).expect("test failed");
+        let schema_str = serde_json::to_string(&schema)?;
+        let _schema = Schema::parse_str(&schema_str)?;
         assert_eq!(schema, _schema);
 
         Ok(())
@@ -941,7 +947,7 @@ mod tests {
         }
         "#;
         let schema = Schema::parse_str(schema)?;
-        let rs = ResolvedSchema::try_from(&schema).expect("Schema didn't successfully parse");
+        let rs = ResolvedSchema::try_from(&schema)?;
 
         // confirm we have expected 2 full-names
         assert_eq!(rs.get_names().len(), 2);
@@ -950,8 +956,8 @@ mod tests {
         }
 
         // convert Schema back to JSON string
-        let schema_str = serde_json::to_string(&schema).expect("test failed");
-        let _schema = Schema::parse_str(&schema_str).expect("test failed");
+        let schema_str = serde_json::to_string(&schema)?;
+        let _schema = Schema::parse_str(&schema_str)?;
         assert_eq!(schema, _schema);
 
         Ok(())
@@ -1016,4 +1022,57 @@ mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn avro_rs_444_do_not_allow_duplicate_names_in_known_schemata() -> TestResult {
+        let schema = Schema::parse_str(
+            r#"{
+            "name": "foo",
+            "type": "record",
+            "fields": [
+                {
+                    "name": "a",
+                    "type": {
+                        "type": "fixed",
+                        "size": 16,
+                        "logicalType": "decimal",
+                        "precision": 4,
+                        "scale": 2,
+                        "name": "bar"
+                    }
+                },
+                {
+                    "name": "b",
+                    "type": "bar"
+                },
+                {
+                    "name": "c",
+                    "type": {
+                        "type": "fixed",
+                        "size": 16,
+                        "logicalType": "uuid",
+                        "name": "duplicated_name"
+                    }
+                }
+            ]
+        }"#,
+        )?;
+
+        let mut known_schemata: NamesRef = HashMap::default();
+        known_schemata.insert("duplicated_name".try_into()?, &Schema::Boolean);
+
+        let result = ResolvedSchema::new_with_known_schemata(vec![&schema], &None, &known_schemata);
+        match result {
+            Ok(_) => {
+                panic!("Expected a AmbiguousSchemaDefinition error for `duplicated_name`")
+            }
+            Err(err) => match err.into_details() {
+                Details::AmbiguousSchemaDefinition(name) => {
+                    assert_eq!(name, "duplicated_name".try_into()?);
+                }
+                details => panic!("Unexpected error: {details}"),
+            },
+        }
+        Ok(())
+    }
 }