[Variant] Support varint's typed_value for DataType::LargeUtf8

Author: klion26

parquet-variant-compute/src/variant_array.rs

@@ -967,6 +967,11 @@ fn typed_value_to_variant<'a>(
             let value = array.value(index);
             Ok(Variant::from(value))
         }
+        DataType::LargeUtf8 => {
+            let array = typed_value.as_string::<i64>();
+            let value = array.value(index);
+            Ok(Variant::from(value))
+        }
         DataType::Int8 => {
             primitive_conversion_single_value!(Int8Type, typed_value, index)
         }
@@ -1165,14 +1170,14 @@ fn canonicalize_and_verify_data_type(data_type: &DataType) -> Result<Cow<'_, Dat
         // Binary and string are allowed. Force Binary to BinaryView because that's what the parquet
         // reader returns and what the rest of the variant code expects.
         Binary => Cow::Owned(DataType::BinaryView),
-        BinaryView | Utf8 => borrow!(),
+        BinaryView | Utf8 | LargeUtf8 => borrow!(),
 
         // UUID maps to 16-byte fixed-size binary; no other width is allowed
         FixedSizeBinary(16) => borrow!(),
         FixedSizeBinary(_) | FixedSizeList(..) => fail!(),
 
         // We can _possibly_ allow (some of) these some day?
-        LargeBinary | LargeUtf8 | Utf8View | ListView(_) | LargeList(_) | LargeListView(_) => {
+        LargeBinary | Utf8View | ListView(_) | LargeList(_) | LargeListView(_) => {
             fail!()
         }
 

parquet-variant-compute/src/variant_get.rs

@@ -311,8 +311,8 @@ mod test {
     use arrow::array::{
         Array, ArrayRef, AsArray, BinaryViewArray, BooleanArray, Date32Array, Decimal32Array,
         Decimal64Array, Decimal128Array, Decimal256Array, Float32Array, Float64Array, Int8Array,
-        Int16Array, Int32Array, Int64Array, NullBuilder, StringArray, StructArray,
-        Time64MicrosecondArray,
+        Int16Array, Int32Array, Int64Array, LargeStringArray, NullBuilder, StringArray,
+        StructArray, Time64MicrosecondArray,
     };
     use arrow::buffer::NullBuffer;
     use arrow::compute::CastOptions;
@@ -1302,6 +1302,25 @@ mod test {
         ])
     );
 
+    perfectly_shredded_variant_array_fn!(large_utf8_gen_array, || {
+        LargeStringArray::from(vec![
+            "Arrow-parquet-variant",
+            "short-string",
+            "apache-arrow-rs-parquet-variant-string-value-the-length-is-bigger-than-sixty-three",
+        ])
+    });
+
+    perfectly_shredded_to_arrow_primitive_test!(
+        large_utf8_test_as_large_utf8,
+        DataType::LargeUtf8,
+        large_utf8_gen_array,
+        LargeStringArray::from(vec![
+            "Arrow-parquet-variant",
+            "short-string",
+            "apache-arrow-rs-parquet-variant-string-value-the-length-is-bigger-than-sixty-three"
+        ])
+    );
+
     /// Return a VariantArray that represents a normal "shredded" variant
     /// for the following example
     ///

parquet-variant-compute/src/variant_to_arrow.rs

@@ -62,6 +62,7 @@ pub(crate) enum PrimitiveVariantToArrowRowBuilder<'a> {
     Time(VariantToPrimitiveArrowRowBuilder<'a, datatypes::Time64MicrosecondType>),
     Date(VariantToPrimitiveArrowRowBuilder<'a, datatypes::Date32Type>),
     Utf8(VariantToUtf8ArrowRowBuilder<'a, i32>),
+    LargeUtf8(VariantToUtf8ArrowRowBuilder<'a, i64>),
 }
 
 /// Builder for converting variant values into strongly typed Arrow arrays.
@@ -104,6 +105,7 @@ impl<'a> PrimitiveVariantToArrowRowBuilder<'a> {
             Time(b) => b.append_null(),
             Date(b) => b.append_null(),
             Utf8(b) => b.append_null(),
+            LargeUtf8(b) => b.append_null(),
         }
     }
 
@@ -134,6 +136,7 @@ impl<'a> PrimitiveVariantToArrowRowBuilder<'a> {
             Time(b) => b.append_value(value),
             Date(b) => b.append_value(value),
             Utf8(b) => b.append_value(value),
+            LargeUtf8(b) => b.append_value(value),
         }
     }
 
@@ -164,6 +167,7 @@ impl<'a> PrimitiveVariantToArrowRowBuilder<'a> {
             Time(b) => b.finish(),
             Date(b) => b.finish(),
             Utf8(b) => b.finish(),
+            LargeUtf8(b) => b.finish(),
         }
     }
 }
@@ -287,6 +291,9 @@ pub(crate) fn make_primitive_variant_to_arrow_row_builder<'a>(
                 VariantToPrimitiveArrowRowBuilder::new(cast_options, capacity),
             ),
             DataType::Utf8 => Utf8(VariantToUtf8ArrowRowBuilder::new(cast_options, capacity)),
+            DataType::LargeUtf8 => {
+                LargeUtf8(VariantToUtf8ArrowRowBuilder::new(cast_options, capacity))
+            }
             _ if data_type.is_primitive() => {
                 return Err(ArrowError::NotYetImplemented(format!(
                     "Primitive data_type {data_type:?} not yet implemented"