Move extension type construction logic out of Field (#9266)

# Which issue does this PR close?

- Part of #8987

# Rationale for this change

The logic to instantiate a type extension does not really depend on
`Field`, other than indirectly because that struct happens to contain
all the necessary bits of information.

As part of the work to make the JSON decoder support extension types, it
was
[observed](#9021 (comment))
that a field is not always available (or at least, not desirable because
it creates redundancy). This change addresses the concern by making it
possible to work directly with extension types instead of being forced
to route through a `Field` instance.

# What changes are included in this PR?

Factor out the body of `Field::try_extension_type` as a new associated
function `ExtensionType::try_new_from_field_metadata` that takes data
type and field metadata map and delegates to `ExtensionType::try_new`.
`Field::try_extension_type` then simply calls that new method.

# Are these changes tested?

Code movement. Existing unit tests validate it.

# Are there any user-facing changes?

New provided trait method.

Author: scovich

arrow-schema/src/extension/canonical/bool8.rs

@@ -96,7 +96,7 @@ mod tests {
     }
 
     #[test]
-    #[should_panic(expected = "Field extension type name missing")]
+    #[should_panic(expected = "Extension type name missing")]
     fn missing_name() {
         let field = Field::new("", DataType::Int8, false).with_metadata(
             [(EXTENSION_TYPE_METADATA_KEY.to_owned(), "".to_owned())]

arrow-schema/src/extension/canonical/fixed_shape_tensor.rs

@@ -471,7 +471,7 @@ mod tests {
     }
 
     #[test]
-    #[should_panic(expected = "Field extension type name missing")]
+    #[should_panic(expected = "Extension type name missing")]
     fn missing_name() {
         let field =
             Field::new_fixed_size_list("", Field::new("", DataType::Float32, false), 3, false)

arrow-schema/src/extension/canonical/json.rs

@@ -222,7 +222,7 @@ mod tests {
     }
 
     #[test]
-    #[should_panic(expected = "Field extension type name missing")]
+    #[should_panic(expected = "Extension type name missing")]
     fn missing_name() {
         let field = Field::new("", DataType::Int8, false).with_metadata(
             [(EXTENSION_TYPE_METADATA_KEY.to_owned(), "{}".to_owned())]

arrow-schema/src/extension/canonical/opaque.rs

@@ -285,7 +285,7 @@ mod tests {
     }
 
     #[test]
-    #[should_panic(expected = "Field extension type name missing")]
+    #[should_panic(expected = "Extension type name missing")]
     fn missing_name() {
         let field = Field::new("", DataType::Null, false).with_metadata(
             [(

arrow-schema/src/extension/canonical/timestamp_with_offset.rs

@@ -300,7 +300,7 @@ mod tests {
     }
 
     #[test]
-    #[should_panic(expected = "Field extension type name missing")]
+    #[should_panic(expected = "Extension type name missing")]
     fn missing_name() {
         let field = make_valid_field_primitive(TimeUnit::Second)
             .with_metadata([(EXTENSION_TYPE_METADATA_KEY.to_owned(), "".to_owned())].into());

arrow-schema/src/extension/canonical/uuid.rs

@@ -100,7 +100,7 @@ mod tests {
     }
 
     #[test]
-    #[should_panic(expected = "Field extension type name missing")]
+    #[should_panic(expected = "Extension type name missing")]
     fn missing_name() {
         let field = Field::new("", DataType::FixedSizeBinary(16), false);
         field.extension_type::<Uuid>();

arrow-schema/src/extension/canonical/variable_shape_tensor.rs

@@ -529,7 +529,7 @@ mod tests {
     }
 
     #[test]
-    #[should_panic(expected = "Field extension type name missing")]
+    #[should_panic(expected = "Extension type name missing")]
     fn missing_name() {
         let field = Field::new_struct(
             "",

arrow-schema/src/extension/mod.rs

@@ -23,6 +23,7 @@ mod canonical;
 pub use canonical::*;
 
 use crate::{ArrowError, DataType};
+use std::collections::HashMap;
 
 /// The metadata key for the string name identifying an [`ExtensionType`].
 pub const EXTENSION_TYPE_NAME_KEY: &str = "ARROW:extension:name";
@@ -255,4 +256,46 @@ pub trait ExtensionType: Sized {
     /// This should return an error if the given data type is not supported by
     /// this extension type.
     fn try_new(data_type: &DataType, metadata: Self::Metadata) -> Result<Self, ArrowError>;
+
+    /// Construct this extension type from field metadata and data type.
+    ///
+    /// This is a provided method that extracts extension type information from
+    /// metadata (using [`EXTENSION_TYPE_NAME_KEY`] and
+    /// [`EXTENSION_TYPE_METADATA_KEY`]) and delegates to [`Self::try_new`].
+    ///
+    /// Returns an error if:
+    /// - The extension type name is missing or doesn't match [`Self::NAME`]
+    /// - Metadata deserialization fails
+    /// - The data type is not supported
+    ///
+    /// This method enables extension type checking without requiring a full
+    /// [`Field`] instance, useful when only metadata and data type are available.
+    ///
+    /// [`Field`]: crate::Field
+    fn try_new_from_field_metadata(
+        data_type: &DataType,
+        metadata: &HashMap<String, String>,
+    ) -> Result<Self, ArrowError> {
+        // Check the extension name in the metadata
+        match metadata.get(EXTENSION_TYPE_NAME_KEY).map(|s| s.as_str()) {
+            // It should match the name of the given extension type
+            Some(name) if name == Self::NAME => {
+                // Deserialize the metadata and try to construct the extension type
+                let ext_metadata = metadata
+                    .get(EXTENSION_TYPE_METADATA_KEY)
+                    .map(|s| s.as_str());
+                let parsed = Self::deserialize_metadata(ext_metadata)?;
+                Self::try_new(data_type, parsed)
+            }
+            // Name mismatch
+            Some(name) => Err(ArrowError::InvalidArgumentError(format!(
+                "Extension type name mismatch: expected {}, got {name}",
+                Self::NAME
+            ))),
+            // Name missing
+            None => Err(ArrowError::InvalidArgumentError(
+                "Extension type name missing".to_string(),
+            )),
+        }
+    }
 }

arrow-schema/src/field.rs

@@ -575,25 +575,7 @@ impl Field {
     /// }
     /// ```
     pub fn try_extension_type<E: ExtensionType>(&self) -> Result<E, ArrowError> {
-        // Check the extension name in the metadata
-        match self.extension_type_name() {
-            // It should match the name of the given extension type
-            Some(name) if name == E::NAME => {
-                // Deserialize the metadata and try to construct the extension
-                // type
-                E::deserialize_metadata(self.extension_type_metadata())
-                    .and_then(|metadata| E::try_new(self.data_type(), metadata))
-            }
-            // Name mismatch
-            Some(name) => Err(ArrowError::InvalidArgumentError(format!(
-                "Field extension type name mismatch, expected {}, found {name}",
-                E::NAME
-            ))),
-            // Name missing
-            None => Err(ArrowError::InvalidArgumentError(
-                "Field extension type name missing".to_owned(),
-            )),
-        }
+        E::try_new_from_field_metadata(self.data_type(), self.metadata())
     }
 
     /// Returns an instance of the given [`ExtensionType`] of this [`Field`],

parquet/src/arrow/schema/virtual_type.rs

@@ -143,7 +143,7 @@ mod tests {
     }
 
     #[test]
-    #[should_panic(expected = "Field extension type name missing")]
+    #[should_panic(expected = "Extension type name missing")]
     fn row_number_missing_name() {
         let field = Field::new("", DataType::Int64, false).with_metadata(
             [(EXTENSION_TYPE_METADATA_KEY.to_owned(), "".to_owned())]
@@ -203,7 +203,7 @@ mod tests {
     }
 
     #[test]
-    #[should_panic(expected = "Field extension type name missing")]
+    #[should_panic(expected = "Extension type name missing")]
     fn row_group_index_missing_name() {
         let field = Field::new("", DataType::Int64, false).with_metadata(
             [(EXTENSION_TYPE_METADATA_KEY.to_owned(), "".to_owned())]