address comments

Author: klion26

parquet-variant-compute/src/variant_get.rs

@@ -319,6 +319,7 @@ mod test {
     use arrow::compute::CastOptions;
     use arrow::datatypes::DataType::{Int16, Int32, Int64};
     use arrow::datatypes::i256;
+    use arrow::util::display::FormatOptions;
     use arrow_schema::DataType::{Boolean, Float32, Float64, Int8};
     use arrow_schema::{DataType, Field, FieldRef, Fields, IntervalUnit, TimeUnit};
     use chrono::DateTime;
@@ -1043,11 +1044,25 @@ mod test {
         Int32Array::from(vec![Some(32), Some(64), Some(48)])
     });
 
+    // We append null values if type miss match happens in safe mode
+    perfectly_shredded_to_arrow_primitive_test!(
+        get_variant_perfectly_shredded_null_with_type_missmatch_in_safe_mode,
+        DataType::Null,
+        perfectly_shredded_null_variant_array_with_int,
+        arrow::array::NullArray::new(3)
+    );
+
+    // We'll return an error if type miss match happens in strict mode
     #[test]
-    fn get_variant_perfectly_shredded_null_as_null_with_type_missmatch() {
+    fn get_variant_perfectly_shredded_null_as_null_with_type_missmatch_in_strict_mode() {
         let array = perfectly_shredded_null_variant_array_with_int();
         let field = Field::new("typed_value", DataType::Null, true);
-        let options = GetOptions::new().with_as_type(Some(FieldRef::from(field)));
+        let options = GetOptions::new()
+            .with_as_type(Some(FieldRef::from(field)))
+            .with_cast_options(CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            });
 
         let result = variant_get(&array, options);
 

parquet-variant-compute/src/variant_to_arrow.rs

@@ -37,7 +37,7 @@ use std::sync::Arc;
 /// `VariantToArrowRowBuilder` (below) and `VariantToShreddedPrimitiveVariantRowBuilder` (in
 /// `shred_variant.rs`).
 pub(crate) enum PrimitiveVariantToArrowRowBuilder<'a> {
-    Null(VariantToNullArrowRowBuilder),
+    Null(VariantToNullArrowRowBuilder<'a>),
     Boolean(VariantToBooleanArrowRowBuilder<'a>),
     Int8(VariantToPrimitiveArrowRowBuilder<'a, datatypes::Int8Type>),
     Int16(VariantToPrimitiveArrowRowBuilder<'a, datatypes::Int16Type>),
@@ -232,7 +232,7 @@ pub(crate) fn make_primitive_variant_to_arrow_row_builder<'a>(
 
     let builder =
         match data_type {
-            DataType::Null => Null(VariantToNullArrowRowBuilder::new(capacity)),
+            DataType::Null => Null(VariantToNullArrowRowBuilder::new(cast_options)),
             DataType::Boolean => {
                 Boolean(VariantToBooleanArrowRowBuilder::new(cast_options, capacity))
             }
@@ -696,10 +696,43 @@ impl VariantToBinaryVariantArrowRowBuilder {
     }
 }
 
-pub(crate) struct VariantToNullArrowRowBuilder {
-    capacity: usize,
+pub(crate) struct VariantToNullArrowRowBuilder<'a> {
+    cast_option: &'a CastOptions<'a>,
+    item_count: usize,
 }
 
+impl<'a> VariantToNullArrowRowBuilder<'a> {
+    fn new(cast_option: &'a CastOptions<'a>) -> Self {
+        Self {
+            cast_option,
+            item_count: 0,
+        }
+    }
+
+    fn append_value(&mut self, value: &Variant<'_, '_>) -> Result<bool> {
+        if value.as_null().is_some() {
+            self.item_count += 1;
+            Ok(true)
+        } else if self.cast_option.safe {
+            self.append_null()?;
+            Ok(false)
+        } else {
+            Err(ArrowError::CastError(format!(
+                "Failed to extract Null from variant {:?} at path VariantPath([])",
+                value
+            )))
+        }
+    }
+
+    fn append_null(&mut self) -> Result<()> {
+        self.item_count += 1;
+        Ok(())
+    }
+
+    fn finish(self) -> Result<ArrayRef> {
+        Ok(Arc::new(NullArray::new(self.item_count)))
+    }
+}
 
 #[cfg(test)]
 mod tests {
@@ -756,28 +789,3 @@ mod tests {
         }
     }
 }
-impl VariantToNullArrowRowBuilder {
-    fn new(capacity: usize) -> Self {
-        Self { capacity }
-    }
-
-    fn append_value(&mut self, value: &Variant<'_, '_>) -> Result<bool> {
-        if value.as_null().is_some() {
-            Ok(true)
-        } else {
-            // Null type only accepts nulls
-            Err(ArrowError::CastError(format!(
-                "Failed to extract Null from variant {:?} at path VariantPath([])",
-                value
-            )))
-        }
-    }
-
-    fn append_null(&mut self) -> Result<()> {
-        Ok(())
-    }
-
-    fn finish(self) -> Result<ArrayRef> {
-        Ok(Arc::new(NullArray::new(self.capacity)))
-    }
-}