Fix arrow-avro type resolver register bug (apache#8046)

# Which issue does this PR close?

- Closes apache#8045

# Rationale for this change

Simple bug fix where the order of `name` and `namespace` is wrong in
Resolver field registration method.

# What changes are included in this PR?

One-line bug fix and corresponding tests.

# Are these changes tested?

- Added a test in the same file to test the fix. Made sure it doesn't
pass with the original code.

# Are there any user-facing changes?

No

Author: yongkyunlee

arrow-avro/src/codec.rs

@@ -431,7 +431,7 @@ struct Resolver<'a> {
 
 impl<'a> Resolver<'a> {
     fn register(&mut self, name: &'a str, namespace: Option<&'a str>, schema: AvroDataType) {
-        self.map.insert((name, namespace.unwrap_or("")), schema);
+        self.map.insert((namespace.unwrap_or(""), name), schema);
     }
 
     fn resolve(&self, name: &str, namespace: Option<&'a str>) -> Result<AvroDataType, ArrowError> {
@@ -660,11 +660,8 @@ fn make_data_type<'a>(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::schema::{
-        Attributes, ComplexType, Fixed, PrimitiveType, Record, Schema, Type, TypeName,
-    };
+    use crate::schema::{Attributes, PrimitiveType, Schema, Type, TypeName};
     use serde_json;
-    use std::collections::HashMap;
 
     fn create_schema_with_logical_type(
         primitive_type: PrimitiveType,
@@ -681,21 +678,6 @@ mod tests {
         })
     }
 
-    fn create_fixed_schema(size: usize, logical_type: &'static str) -> Schema<'static> {
-        let attributes = Attributes {
-            logical_type: Some(logical_type),
-            additional: Default::default(),
-        };
-
-        Schema::Complex(ComplexType::Fixed(Fixed {
-            name: "fixed_type",
-            namespace: None,
-            aliases: Vec::new(),
-            size,
-            attributes,
-        }))
-    }
-
     #[test]
     fn test_date_logical_type() {
         let schema = create_schema_with_logical_type(PrimitiveType::Int, "date");
@@ -897,4 +879,162 @@ mod tests {
             _ => panic!("Expected SchemaError"),
         }
     }
+
+    #[test]
+    fn test_nested_record_type_reuse_without_namespace() {
+        let schema_str = r#"
+        {
+          "type": "record",
+          "name": "Record",
+          "fields": [
+            {
+              "name": "nested",
+              "type": {
+                "type": "record",
+                "name": "Nested",
+                "fields": [
+                  { "name": "nested_int", "type": "int" }
+                ]
+              }
+            },
+            { "name": "nestedRecord", "type": "Nested" },
+            { "name": "nestedArray", "type": { "type": "array", "items": "Nested" } },
+            { "name": "nestedMap", "type": { "type": "map", "values": "Nested" } }
+          ]
+        }
+        "#;
+
+        let schema: Schema = serde_json::from_str(schema_str).unwrap();
+
+        let mut resolver = Resolver::default();
+        let avro_data_type = make_data_type(&schema, None, &mut resolver, false, false).unwrap();
+
+        if let Codec::Struct(fields) = avro_data_type.codec() {
+            assert_eq!(fields.len(), 4);
+
+            // nested
+            assert_eq!(fields[0].name(), "nested");
+            let nested_data_type = fields[0].data_type();
+            if let Codec::Struct(nested_fields) = nested_data_type.codec() {
+                assert_eq!(nested_fields.len(), 1);
+                assert_eq!(nested_fields[0].name(), "nested_int");
+                assert!(matches!(nested_fields[0].data_type().codec(), Codec::Int32));
+            } else {
+                panic!(
+                    "'nested' field is not a struct but {:?}",
+                    nested_data_type.codec()
+                );
+            }
+
+            // nestedRecord
+            assert_eq!(fields[1].name(), "nestedRecord");
+            let nested_record_data_type = fields[1].data_type();
+            assert_eq!(
+                nested_record_data_type.codec().data_type(),
+                nested_data_type.codec().data_type()
+            );
+
+            // nestedArray
+            assert_eq!(fields[2].name(), "nestedArray");
+            if let Codec::List(item_type) = fields[2].data_type().codec() {
+                assert_eq!(
+                    item_type.codec().data_type(),
+                    nested_data_type.codec().data_type()
+                );
+            } else {
+                panic!("'nestedArray' field is not a list");
+            }
+
+            // nestedMap
+            assert_eq!(fields[3].name(), "nestedMap");
+            if let Codec::Map(value_type) = fields[3].data_type().codec() {
+                assert_eq!(
+                    value_type.codec().data_type(),
+                    nested_data_type.codec().data_type()
+                );
+            } else {
+                panic!("'nestedMap' field is not a map");
+            }
+        } else {
+            panic!("Top-level schema is not a struct");
+        }
+    }
+
+    #[test]
+    fn test_nested_enum_type_reuse_with_namespace() {
+        let schema_str = r#"
+        {
+          "type": "record",
+          "name": "Record",
+          "namespace": "record_ns",
+          "fields": [
+            {
+              "name": "status",
+              "type": {
+                "type": "enum",
+                "name": "Status",
+                "namespace": "enum_ns",
+                "symbols": ["ACTIVE", "INACTIVE", "PENDING"]
+              }
+            },
+            { "name": "backupStatus", "type": "enum_ns.Status" },
+            { "name": "statusHistory", "type": { "type": "array", "items": "enum_ns.Status" } },
+            { "name": "statusMap", "type": { "type": "map", "values": "enum_ns.Status" } }
+          ]
+        }
+        "#;
+
+        let schema: Schema = serde_json::from_str(schema_str).unwrap();
+
+        let mut resolver = Resolver::default();
+        let avro_data_type = make_data_type(&schema, None, &mut resolver, false, false).unwrap();
+
+        if let Codec::Struct(fields) = avro_data_type.codec() {
+            assert_eq!(fields.len(), 4);
+
+            // status
+            assert_eq!(fields[0].name(), "status");
+            let status_data_type = fields[0].data_type();
+            if let Codec::Enum(symbols) = status_data_type.codec() {
+                assert_eq!(symbols.as_ref(), &["ACTIVE", "INACTIVE", "PENDING"]);
+            } else {
+                panic!(
+                    "'status' field is not an enum but {:?}",
+                    status_data_type.codec()
+                );
+            }
+
+            // backupStatus
+            assert_eq!(fields[1].name(), "backupStatus");
+            let backup_status_data_type = fields[1].data_type();
+            assert_eq!(
+                backup_status_data_type.codec().data_type(),
+                status_data_type.codec().data_type()
+            );
+
+            // statusHistory
+            assert_eq!(fields[2].name(), "statusHistory");
+            if let Codec::List(item_type) = fields[2].data_type().codec() {
+                assert_eq!(
+                    item_type.codec().data_type(),
+                    status_data_type.codec().data_type()
+                );
+            } else {
+                panic!("'statusHistory' field is not a list");
+            }
+
+            // statusMap
+            assert_eq!(fields[3].name(), "statusMap");
+            if let Codec::Map(value_type) = fields[3].data_type().codec() {
+                assert_eq!(
+                    value_type.codec().data_type(),
+                    status_data_type.codec().data_type()
+                );
+            } else {
+                panic!("'statusMap' field is not a map");
+            }
+        } else {
+            panic!("Top-level schema is not a struct");
+        }
+    }
 }