Add canonical UUID support and clean up UUID parsing:

- Introduced `canonical_extension_types` feature for standardized UUID handling.
- Added `Uuid` crate dependency for parsing and validating UUIDs.
- Updated `field_with_name` method to support canonical UUID representation.
- Removed custom UUID parsing logic and replaced it with `Uuid` crate functionality.
- Updated `Cargo.toml` accordingly.

Author: jecsand838

arrow-avro/Cargo.toml

@@ -39,6 +39,7 @@ all-features = true
 default = ["deflate", "snappy", "zstd"]
 deflate = ["flate2"]
 snappy = ["snap", "crc"]
+canonical_extension_types = ["arrow-schema/canonical_extension_types"]
 
 [dependencies]
 arrow-schema = { workspace = true }
@@ -50,6 +51,7 @@ flate2 = { version = "1.0", default-features = false, features = ["rust_backend"
 snap = { version = "1.0", default-features = false, optional = true }
 zstd = { version = "0.13", default-features = false, optional = true }
 crc = { version = "3.0", optional = true }
+uuid = "1.17"
 
 [dev-dependencies]
 rand = { version = "0.9", default-features = false, features = ["std", "std_rng", "thread_rng"] }

arrow-avro/src/codec.rs

@@ -61,9 +61,25 @@ impl AvroDataType {
     }
 
     /// Returns an arrow [`Field`] with the given name
+    #[cfg(feature = "canonical_extension_types")]
     pub fn field_with_name(&self, name: &str) -> Field {
-        let d = self.codec.data_type();
-        Field::new(name, d, self.nullability.is_some()).with_metadata(self.metadata.clone())
+        let nullable = self.nullability.is_some();
+        let data_type = self.codec.data_type();
+        let field = match self.codec {
+            Codec::Uuid => Field::new(name, data_type, nullable)
+                .with_extension_type(arrow_schema::extension::Uuid),
+            _ => Field::new(name, data_type, nullable),
+        };
+        field.with_metadata(self.metadata.clone())
+    }
+
+    /// Returns an arrow [`Field`] with the given name
+    #[cfg(not(feature = "canonical_extension_types"))]
+    pub fn field_with_name(&self, name: &str) -> Field {
+        let nullable = self.nullability.is_some();
+        let data_type = self.codec.data_type();
+        let field = Field::new(name, data_type, nullable);
+        field.with_metadata(self.metadata.clone())
     }
 
     /// Returns a reference to the codec used by this data type

arrow-avro/src/reader/record.rs

@@ -36,6 +36,7 @@ use std::cmp::Ordering;
 use std::collections::HashMap;
 use std::io::Read;
 use std::sync::Arc;
+use uuid::Uuid;
 
 const DEFAULT_CAPACITY: usize = 1024;
 
@@ -321,8 +322,12 @@ impl Decoder {
             }
             Self::Uuid(values) => {
                 let s_bytes = buf.get_bytes()?;
-                let uuid_bytes = parse_uuid_bytes(s_bytes)?;
-                values.extend_from_slice(&uuid_bytes);
+                let s = std::str::from_utf8(s_bytes).map_err(|e| {
+                    ArrowError::ParseError(format!("UUID bytes are not valid UTF-8: {e}"))
+                })?;
+                let uuid = Uuid::try_parse(s)
+                    .map_err(|e| ArrowError::ParseError(format!("Failed to parse uuid: {e}")))?;
+                values.extend_from_slice(uuid.as_bytes());
             }
             Self::Array(_, off, encoding) => {
                 let total_items = read_blocks(buf, |cursor| encoding.decode(cursor))?;
@@ -619,46 +624,6 @@ fn sign_extend_to<const N: usize>(raw: &[u8]) -> Result<[u8; N], ArrowError> {
     Ok(arr)
 }
 
-#[inline]
-fn hex_char_to_u8(c: u8) -> Result<u8, ArrowError> {
-    match c {
-        b'0'..=b'9' => Ok(c - b'0'),
-        b'a'..=b'f' => Ok(c - b'a' + 10),
-        b'A'..=b'F' => Ok(c - b'A' + 10),
-        _ => Err(ArrowError::ParseError(format!(
-            "Invalid hex character '{c}' in UUID string",
-        ))),
-    }
-}
-
-#[inline]
-fn parse_uuid_bytes(s_bytes: &[u8]) -> Result<[u8; 16], ArrowError> {
-    if s_bytes.len() != 36 {
-        return Err(ArrowError::ParseError(format!(
-            "Invalid UUID string length: expected 36, got {}",
-            s_bytes.len()
-        )));
-    }
-    let mut bytes = [0u8; 16];
-    let mut str_idx = 0;
-    for byte_chunk in bytes.iter_mut() {
-        if str_idx == 8 || str_idx == 13 || str_idx == 18 || str_idx == 23 {
-            if s_bytes[str_idx] != b'-' {
-                return Err(ArrowError::ParseError(format!(
-                    "Invalid UUID format: expected hyphen at index {str_idx}"
-                )));
-            }
-            str_idx += 1;
-        }
-        let high_nibble = hex_char_to_u8(s_bytes[str_idx])?;
-        str_idx += 1;
-        let low_nibble = hex_char_to_u8(s_bytes[str_idx])?;
-        str_idx += 1;
-        *byte_chunk = (high_nibble << 4) | low_nibble;
-    }
-    Ok(bytes)
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;