[Variant] Add Variant type access for DataType::Binary

Author: klion26

parquet-variant-compute/src/variant_get.rs

@@ -309,10 +309,10 @@ mod test {
     use crate::variant_array::{ShreddedVariantFieldArray, StructArrayBuilder};
     use crate::{VariantArray, VariantArrayBuilder, json_to_variant};
     use arrow::array::{
-        Array, ArrayRef, AsArray, BinaryViewArray, BooleanArray, Date32Array, Decimal32Array,
-        Decimal64Array, Decimal128Array, Decimal256Array, Float32Array, Float64Array, Int8Array,
-        Int16Array, Int32Array, Int64Array, LargeStringArray, NullBuilder, StringArray,
-        StructArray, Time64MicrosecondArray,
+        Array, ArrayRef, AsArray, BinaryArray, BinaryViewArray, BooleanArray, Date32Array,
+        Decimal32Array, Decimal64Array, Decimal128Array, Decimal256Array, Float32Array,
+        Float64Array, Int8Array, Int16Array, Int32Array, Int64Array, LargeStringArray, NullBuilder,
+        StringArray, StructArray, Time64MicrosecondArray,
     };
     use arrow::buffer::NullBuffer;
     use arrow::compute::CastOptions;
@@ -1321,6 +1321,25 @@ mod test {
         ])
     );
 
+    perfectly_shredded_variant_array_fn!(perfectly_shredded_binary_variant_array, || {
+        BinaryArray::from(vec![
+            Some(b"Arrow-parquet-variant" as &[u8]),
+            Some(b"binary-value" as &[u8]),
+            Some(b"apache-arrow-rs-parquet-variant-binary" as &[u8]),
+        ])
+    });
+
+    perfectly_shredded_to_arrow_primitive_test!(
+        get_variant_perfectly_shredded_binary_as_binary,
+        DataType::Binary,
+        perfectly_shredded_binary_variant_array,
+        BinaryArray::from(vec![
+            Some(b"Arrow-parquet-variant" as &[u8]),
+            Some(b"binary-value" as &[u8]),
+            Some(b"apache-arrow-rs-parquet-variant-binary" as &[u8]),
+        ])
+    );
+
     /// Return a VariantArray that represents a normal "shredded" variant
     /// for the following example
     ///

parquet-variant-compute/src/variant_to_arrow.rs

@@ -16,11 +16,11 @@
 // under the License.
 
 use arrow::array::{
-    ArrayRef, BinaryViewArray, BooleanBuilder, GenericStringBuilder, NullArray, NullBufferBuilder,
-    OffsetSizeTrait, PrimitiveBuilder,
+    ArrayRef, BinaryViewArray, BooleanBuilder, GenericByteBuilder, GenericStringBuilder, NullArray,
+    NullBufferBuilder, OffsetSizeTrait, PrimitiveBuilder,
 };
 use arrow::compute::{CastOptions, DecimalCast};
-use arrow::datatypes::{self, DataType, DecimalType};
+use arrow::datatypes::{self, DataType, DecimalType, GenericBinaryType};
 use arrow::error::{ArrowError, Result};
 use parquet_variant::{Variant, VariantPath};
 
@@ -63,6 +63,7 @@ pub(crate) enum PrimitiveVariantToArrowRowBuilder<'a> {
     Date(VariantToPrimitiveArrowRowBuilder<'a, datatypes::Date32Type>),
     Utf8(VariantToUtf8ArrowRowBuilder<'a, i32>),
     LargeUtf8(VariantToUtf8ArrowRowBuilder<'a, i64>),
+    Binary(VariantToBinaryRowBuilder<'a>),
 }
 
 /// Builder for converting variant values into strongly typed Arrow arrays.
@@ -106,6 +107,7 @@ impl<'a> PrimitiveVariantToArrowRowBuilder<'a> {
             Date(b) => b.append_null(),
             Utf8(b) => b.append_null(),
             LargeUtf8(b) => b.append_null(),
+            Binary(b) => b.append_null(),
         }
     }
 
@@ -137,6 +139,7 @@ impl<'a> PrimitiveVariantToArrowRowBuilder<'a> {
             Date(b) => b.append_value(value),
             Utf8(b) => b.append_value(value),
             LargeUtf8(b) => b.append_value(value),
+            Binary(b) => b.append_value(value),
         }
     }
 
@@ -168,6 +171,7 @@ impl<'a> PrimitiveVariantToArrowRowBuilder<'a> {
             Date(b) => b.finish(),
             Utf8(b) => b.finish(),
             LargeUtf8(b) => b.finish(),
+            Binary(b) => b.finish(),
         }
     }
 }
@@ -294,6 +298,7 @@ pub(crate) fn make_primitive_variant_to_arrow_row_builder<'a>(
             DataType::LargeUtf8 => {
                 LargeUtf8(VariantToUtf8ArrowRowBuilder::new(cast_options, capacity))
             }
+            DataType::Binary => Binary(VariantToBinaryRowBuilder::new(cast_options, capacity)),
             _ if data_type.is_primitive() => {
                 return Err(ArrowError::NotYetImplemented(format!(
                     "Primitive data_type {data_type:?} not yet implemented"
@@ -478,6 +483,13 @@ define_variant_to_primitive_builder!(
     type_name: format!("{}Utf8", O::PREFIX)
 );
 
+define_variant_to_primitive_builder!(
+    struct VariantToBinaryRowBuilder<'a>
+    |capacity| -> GenericByteBuilder<GenericBinaryType<i32>> { GenericByteBuilder::<GenericBinaryType<i32>>::with_capacity(capacity, 1024) },
+    |value| value.as_u8_slice(),
+    type_name: "Binary"
+);
+
 /// Builder for converting variant values to arrow Decimal values
 pub(crate) struct VariantToDecimalArrowRowBuilder<'a, T>
 where