[FIX] refactor code for modularity

Author: carpecodeum

parquet-variant-compute/src/variant_array.rs

@@ -169,7 +169,7 @@ impl VariantArray {
     }
 
     /// Get the metadata bytes for a specific index
-    pub fn metadata(&self, index: usize) -> &[u8] {
+    pub fn metadata_bytes(&self, index: usize) -> &[u8] {
         self.metadata_field().as_binary_view().value(index).as_ref()
     }
 
@@ -210,19 +210,15 @@ impl VariantArray {
             if self.is_null(i) {
                 builder.append_null();
             } else {
-                match FieldOperations::remove_field_bytes(
-                    self.metadata(i),
+                let new_value = FieldOperations::remove_field_bytes(
+                    self.metadata_bytes(i),
                     self.value_bytes(i),
                     field_name,
-                )? {
-                    Some(new_value) => {
-                        builder.append_variant_buffers(self.metadata(i), &new_value);
-                    }
-                    None => {
-                        // Field didn't exist, use original value
-                        builder.append_variant_buffers(self.metadata(i), self.value_bytes(i));
-                    }
-                }
+                )?;
+
+                // Use original value if the field didn't exist
+                let new_value = new_value.as_deref().unwrap_or_else(|| self.value_bytes(i));
+                builder.append_variant_buffers(self.metadata_bytes(i), new_value);
             }
         }
 
@@ -237,19 +233,15 @@ impl VariantArray {
             if self.is_null(i) {
                 builder.append_null();
             } else {
-                match FieldOperations::remove_fields_bytes(
-                    self.metadata(i),
+                let new_value = FieldOperations::remove_fields_bytes(
+                    self.metadata_bytes(i),
                     self.value_bytes(i),
                     field_names,
-                )? {
-                    Some(new_value) => {
-                        builder.append_variant_buffers(self.metadata(i), &new_value);
-                    }
-                    None => {
-                        // No fields existed, use original value
-                        builder.append_variant_buffers(self.metadata(i), self.value_bytes(i));
-                    }
-                }
+                )?;
+
+                // Use original value if no fields existed
+                let new_value = new_value.as_deref().unwrap_or_else(|| self.value_bytes(i));
+                builder.append_variant_buffers(self.metadata_bytes(i), new_value);
             }
         }
 

parquet-variant-compute/src/variant_parser.rs

@@ -28,15 +28,6 @@ pub enum VariantBasicType {
     Array = 3,
 }
 
-/// Variant type enumeration covering all possible types
-#[derive(Debug, Clone, PartialEq)]
-pub enum VariantType {
-    Primitive(PrimitiveType),
-    ShortString(ShortStringHeader),
-    Object(ObjectHeader),
-    Array(ArrayHeader),
-}
-
 /// Primitive type variants
 #[derive(Debug, Clone, PartialEq)]
 pub enum PrimitiveType {
@@ -59,6 +50,15 @@ pub enum PrimitiveType {
     String,
 }
 
+/// Variant type enumeration covering all possible types
+#[derive(Debug, Clone, PartialEq)]
+pub enum VariantType {
+    Primitive(PrimitiveType),
+    ShortString(ShortStringHeader),
+    Object(ObjectHeader),
+    Array(ArrayHeader),
+}
+
 /// Short string header structure
 #[derive(Debug, Clone, PartialEq)]
 pub struct ShortStringHeader {
@@ -150,6 +150,19 @@ impl VariantParser {
         }
     }
 
+    /// Get the basic type from header byte
+    pub fn get_basic_type(header_byte: u8) -> VariantBasicType {
+        match header_byte & 0x03 {
+            0 => VariantBasicType::Primitive,
+            1 => VariantBasicType::ShortString,
+            2 => VariantBasicType::Object,
+            3 => VariantBasicType::Array,
+            _ => panic!("Invalid basic type: {}", header_byte & 0x03),
+        }
+    }
+
+
+
     /// Parse short string header
     pub fn parse_short_string_header(header_byte: u8) -> Result<ShortStringHeader, ArrowError> {
         let length = (header_byte >> 2) as usize;
@@ -259,16 +272,7 @@ impl VariantParser {
         }
     }
 
-    /// Get the basic type from header byte
-    pub fn get_basic_type(header_byte: u8) -> VariantBasicType {
-        match header_byte & 0x03 {
-            0 => VariantBasicType::Primitive,
-            1 => VariantBasicType::ShortString,
-            2 => VariantBasicType::Object,
-            3 => VariantBasicType::Array,
-            _ => panic!("Invalid basic type: {}", header_byte & 0x03),
-        }
-    }
+
 
     /// Check if value bytes represent a primitive
     pub fn is_primitive(value_bytes: &[u8]) -> bool {