Erro handling

Signed-off-by: Adam Gutglick <adam@spiraldb.com>

Author: AdamGS

parquet-variant-compute/src/shred_variant.rs

@@ -932,7 +932,7 @@ mod tests {
                             );
                         }
                         None => {
-                            assert!(fallbacks.0.is_null(idx));
+                            assert!(fallback_value.is_null(idx));
                         }
                     }
                 }

parquet-variant-compute/src/unshred_variant.rs

@@ -76,8 +76,11 @@ pub fn unshred_variant(array: &VariantArray) -> Result<VariantArray> {
         if array.is_null(i) {
             value_builder.append_null();
         } else {
-            let metadata_bytes = binary_array_value(metadata.as_ref(), i)
-                .expect("metadata field must be a binary-like array");
+            let metadata_bytes = binary_array_value(metadata.as_ref(), i).ok_or_else(|| {
+                ArrowError::InvalidArgumentError(
+                    "metadata field must be a binary-like array".to_string(),
+                )
+            })?;
             let metadata = VariantMetadata::new(metadata_bytes);
             let mut value_builder = value_builder.builder_ext(&metadata);
             row_builder.append_row(&mut value_builder, &metadata, i)?;
@@ -330,8 +333,11 @@ impl<'a> ValueOnlyUnshredVariantBuilder<'a> {
         if self.value.is_null(index) {
             builder.append_null();
         } else {
-            let value_bytes = binary_array_value(self.value.as_ref(), index)
-                .expect("value field must be a binary-like array");
+            let value_bytes = binary_array_value(self.value.as_ref(), index).ok_or_else(|| {
+                ArrowError::InvalidArgumentError(
+                    "value field must be a binary-like array".to_string(),
+                )
+            })?;
             let variant = Variant::new_with_metadata(metadata.clone(), value_bytes);
             builder.append_value(variant);
         }
@@ -354,11 +360,17 @@ trait AppendToVariantBuilder: Array {
 macro_rules! handle_unshredded_case {
     ($self:expr, $builder:expr, $metadata:expr, $index:expr, $partial_shredding:expr) => {{
         let value = $self.value.as_ref().filter(|v| v.is_valid($index));
-        let value = value.map(|v| {
-            let bytes = binary_array_value(v.as_ref(), $index)
-                .expect("value field must be a binary-like array");
-            Variant::new_with_metadata($metadata.clone(), bytes)
-        });
+        let value = value
+            .map(|v| {
+                let bytes = binary_array_value(v.as_ref(), $index).ok_or_else(|| {
+                    ArrowError::InvalidArgumentError(format!(
+                        "value field must be a binary-like array, instead got {}",
+                        v.data_type(),
+                    ))
+                })?;
+                Result::Ok(Variant::new_with_metadata($metadata.clone(), bytes))
+            })
+            .transpose()?;
 
         // If typed_value is null, handle unshredded case and return early
         if $self.typed_value.is_null($index) {

parquet-variant-compute/src/variant_array.rs

@@ -51,17 +51,12 @@ pub(crate) fn binary_array_value(array: &dyn Array, index: usize) -> Option<&[u8
     }
 }
 
-/// Returns `true` if the data type is `Binary`, `LargeBinary`, or `BinaryView`.
-fn is_binary_like(dt: &DataType) -> bool {
-    matches!(
-        dt,
-        DataType::Binary | DataType::LargeBinary | DataType::BinaryView
-    )
-}
-
 /// Validates that an array has a binary-like data type.
 fn validate_binary_array(array: &dyn Array, field_name: &str) -> Result<()> {
-    if is_binary_like(array.data_type()) {
+    if matches!(
+        array.data_type(),
+        DataType::Binary | DataType::LargeBinary | DataType::BinaryView
+    ) {
         Ok(())
     } else {
         Err(ArrowError::InvalidArgumentError(format!(
@@ -397,10 +392,19 @@ impl VariantArray {
             }
             // Otherwise fall back to value, if available
             (_, Some(value)) if value.is_valid(index) => {
-                let metadata = binary_array_value(self.metadata.as_ref(), index)
-                    .expect("metadata field must be a binary-like array");
-                let value = binary_array_value(value.as_ref(), index)
-                    .expect("value field must be a binary-like array");
+                let metadata =
+                    binary_array_value(self.metadata.as_ref(), index).ok_or_else(|| {
+                        ArrowError::InvalidArgumentError(format!(
+                            "metadata field must be a binary-like array, instead got {}",
+                            self.metadata.data_type(),
+                        ))
+                    })?;
+                let value = binary_array_value(value.as_ref(), index).ok_or_else(|| {
+                    ArrowError::InvalidArgumentError(format!(
+                        "value field must be a binary-like array, instead got {}",
+                        value.data_type(),
+                    ))
+                })?;
                 Ok(Variant::new(metadata, value))
             }
             // It is technically invalid for neither value nor typed_value fields to be available,
@@ -983,9 +987,19 @@ fn typed_value_to_variant<'a>(
             let value = array.value(index);
             Ok(Uuid::from_slice(value).unwrap().into()) // unwrap is safe: slice is always 16 bytes
         }
-        DataType::Binary | DataType::LargeBinary | DataType::BinaryView => {
-            let value = binary_array_value(typed_value.as_ref(), index)
-                .expect("match arm guarantees the array is binary-like");
+        DataType::Binary => {
+            let array = typed_value.as_binary::<i32>();
+            let value = array.value(index);
+            Ok(Variant::from(value))
+        }
+        DataType::LargeBinary => {
+            let array = typed_value.as_binary::<i64>();
+            let value = array.value(index);
+            Ok(Variant::from(value))
+        }
+        DataType::BinaryView => {
+            let array = typed_value.as_binary_view();
+            let value = array.value(index);
             Ok(Variant::from(value))
         }
         DataType::Utf8 => {