fill

Author: alamb

parquet-variant-compute/src/variant_get/output/primitive.rs

@@ -15,12 +15,13 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::env::var;
 use crate::variant_get::output::OutputBuilder;
 use crate::VariantArray;
 use arrow::array::{Array, ArrayRef, ArrowPrimitiveType, AsArray, BinaryViewArray, NullBufferBuilder, PrimitiveArray};
 use arrow::compute::{cast_with_options, CastOptions};
 use arrow_schema::{ArrowError, FieldRef};
-use parquet_variant::VariantPath;
+use parquet_variant::{Variant, VariantPath};
 use std::marker::PhantomData;
 use std::sync::Arc;
 
@@ -64,7 +65,7 @@ impl<'a, T: ArrowPrimitiveType> OutputBuilder for PrimitiveOutputBuilder<'a, T>
         let mut values = Vec::with_capacity(variant_array.len());
         let typed_value =
             cast_with_options(typed_value, &self.as_type.data_type(), &self.cast_options)?;
-        // downcast to the primitive type
+        // downcast to the primitive array (e.g. Int32Array, Float64Array, etc)
         let typed_value = typed_value.as_primitive::<T>();
 
         for i in 0..variant_array.len() {
@@ -74,19 +75,30 @@ impl<'a, T: ArrowPrimitiveType> OutputBuilder for PrimitiveOutputBuilder<'a, T>
                 continue;
             }
 
-            nulls.append_non_null();
 
+            // if the typed value is null, decode the variant and extract the value
             if typed_value.is_null(i) {
-                todo!()
-                /*
-                // fall back to the value (variant) field
-                if let Some(value) = variant_array.value(i) {
-                    // extract the path from the variant and try to convert it to the desired type
-                    let extracted = value.get_path(&self.path)
-                }
-                */
+                // todo follow path
+                let Some(variant) = variant_array.value(i) else {
+                    nulls.append_null();
+                    values.push(T::default_value()); // not used, placeholder
+                    continue;
+                };
+
+                let Some(value) = extract_primitive_from_variant::<T>(&variant) else {
+                    return Err(ArrowError::CastError(format!(
+                        "Failed to extract primitive of type {:?} from variant {:?} at path {:?}",
+                        self.as_type.data_type(),
+                        variant,
+                        self.path
+                    )));
+                };
+
+                nulls.append_non_null();
+                values.push(value)
             } else {
                 // otherwise we have a typed value, so we can use it directly
+            nulls.append_non_null();
                 values.push(typed_value.value(i));
             }
         }
@@ -125,3 +137,8 @@ impl<'a, T: ArrowPrimitiveType> OutputBuilder for PrimitiveOutputBuilder<'a, T>
         todo!()
     }
 }
+
+/// extract a primitive value from a variant
+fn extract_primitive_from_variant<T: ArrowPrimitiveType>(variant: &Variant) -> Option<T::Native> {
+    todo!()
+}