[ADD] add support for shredded objects

Author: carpecodeum

parquet-variant-compute/src/variant_array.rs

@@ -250,7 +250,10 @@ impl VariantArray {
 ///
 /// Finally, `v.typed_value.a.typed_value.b.value` is either NULL (`v:a.b` was an integer) or else a
 /// variant value.
+#[derive(Debug)]
 pub struct ShreddedVariantFieldArray {
+    /// Reference to the underlying StructArray
+    inner: StructArray,
     shredding_state: ShreddingState,
 }
 
@@ -277,15 +280,17 @@ impl ShreddedVariantFieldArray {
     ///
     /// Currently, only `value` columns of type [`BinaryViewArray`] are supported.
     pub fn try_new(inner: ArrayRef) -> Result<Self, ArrowError> {
-        let Some(inner) = inner.as_struct_opt() else {
+        let Some(inner_struct) = inner.as_struct_opt() else {
             return Err(ArrowError::InvalidArgumentError(
-                "Invalid VariantArray: requires StructArray as input".to_string(),
+                "Invalid ShreddedVariantFieldArray: requires StructArray as input".to_string(),
             ));
         };
 
         // Note this clone is cheap, it just bumps the ref count
+        let inner = inner_struct.clone();
         Ok(Self {
-            shredding_state: ShreddingState::try_new(inner)?,
+            inner: inner.clone(),
+            shredding_state: ShreddingState::try_new(&inner)?,
         })
     }
 
@@ -303,6 +308,62 @@ impl ShreddedVariantFieldArray {
     pub fn typed_value_field(&self) -> Option<&ArrayRef> {
         self.shredding_state.typed_value_field()
     }
+
+    /// Returns a reference to the underlying [`StructArray`].
+    pub fn inner(&self) -> &StructArray {
+        &self.inner
+    }
+}
+
+impl Array for ShreddedVariantFieldArray {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn to_data(&self) -> ArrayData {
+        self.inner.to_data()
+    }
+
+    fn into_data(self) -> ArrayData {
+        self.inner.into_data()
+    }
+
+    fn data_type(&self) -> &DataType {
+        self.inner.data_type()
+    }
+
+    fn slice(&self, offset: usize, length: usize) -> ArrayRef {
+        let inner = self.inner.slice(offset, length);
+        let shredding_state = self.shredding_state.slice(offset, length);
+        Arc::new(Self {
+            inner,
+            shredding_state,
+        })
+    }
+
+    fn len(&self) -> usize {
+        self.inner.len()
+    }
+
+    fn is_empty(&self) -> bool {
+        self.inner.is_empty()
+    }
+
+    fn offset(&self) -> usize {
+        self.inner.offset()
+    }
+
+    fn nulls(&self) -> Option<&NullBuffer> {
+        self.inner.nulls()
+    }
+
+    fn get_buffer_memory_size(&self) -> usize {
+        self.inner.get_buffer_memory_size()
+    }
+
+    fn get_array_memory_size(&self) -> usize {
+        self.inner.get_array_memory_size()
+    }
 }
 
 /// Represents the shredding state of a [`VariantArray`]