diff --git a/parquet-variant-compute/src/shred_variant.rs b/parquet-variant-compute/src/shred_variant.rs index d5635291f712..fe3bfb3d0e75 100644 --- a/parquet-variant-compute/src/shred_variant.rs +++ b/parquet-variant-compute/src/shred_variant.rs @@ -309,7 +309,7 @@ impl<'a> VariantToShreddedObjectVariantRowBuilder<'a> { let (value, typed_value, nulls) = typed_value_builder.finish()?; let array = ShreddedVariantFieldArray::from_parts(Some(value), Some(typed_value), nulls); - builder = builder.with_field(field_name, ArrayRef::from(array), false); + builder = builder.with_column(field_name, ArrayRef::from(array), false); } if let Some(nulls) = self.typed_value_nulls.finish() { builder = builder.with_nulls(nulls); @@ -400,6 +400,7 @@ mod tests { let typed_value_field = result .typed_value_field() .unwrap() + .1 .as_any() .downcast_ref::() .unwrap(); @@ -459,6 +460,7 @@ mod tests { let typed_value_int32 = result_int32 .typed_value_field() .unwrap() + .1 .as_any() .downcast_ref::() .unwrap(); @@ -471,6 +473,7 @@ mod tests { let typed_value_float64 = result_float64 .typed_value_field() .unwrap() + .1 .as_any() .downcast_ref::() .unwrap(); @@ -550,6 +553,7 @@ mod tests { let typed_value = result .typed_value_field() .unwrap() + .1 .as_any() .downcast_ref::() .unwrap(); @@ -570,6 +574,7 @@ mod tests { let score_typed_value = score_field .typed_value_field() .unwrap() + .1 .as_any() .downcast_ref::() .unwrap(); @@ -582,6 +587,7 @@ mod tests { let age_typed_value = age_field .typed_value_field() .unwrap() + .1 .as_any() .downcast_ref::() .unwrap(); @@ -912,6 +918,7 @@ mod tests { let typed_value_field = result .typed_value_field() .unwrap() + .1 .as_any() .downcast_ref::() .unwrap(); diff --git a/parquet-variant-compute/src/unshred_variant.rs b/parquet-variant-compute/src/unshred_variant.rs index c20bb697903c..9fc4491c63cd 100644 --- a/parquet-variant-compute/src/unshred_variant.rs +++ b/parquet-variant-compute/src/unshred_variant.rs @@ -164,7 +164,7 @@ impl<'a> UnshredVariantRowBuilder<'a> { fn try_new_opt(shredding_state: BorrowedShreddingState<'a>) -> Result> { let value = shredding_state.value_field(); let typed_value = shredding_state.typed_value_field(); - let Some(typed_value) = typed_value else { + let Some((_, typed_value)) = typed_value else { // Copy the value across directly, if present. Else caller decides what to do. return Ok(value.map(|v| Self::ValueOnly(ValueOnlyUnshredVariantBuilder::new(v)))); }; diff --git a/parquet-variant-compute/src/variant_array.rs b/parquet-variant-compute/src/variant_array.rs index 2b38081d07e2..8c498cea82d1 100644 --- a/parquet-variant-compute/src/variant_array.rs +++ b/parquet-variant-compute/src/variant_array.rs @@ -289,13 +289,24 @@ impl VariantArray { nulls: Option, ) -> Self { let mut builder = - StructArrayBuilder::new().with_field("metadata", Arc::new(metadata.clone()), false); + StructArrayBuilder::new().with_column("metadata", Arc::new(metadata.clone()), false); if let Some(value) = value.clone() { - builder = builder.with_field("value", Arc::new(value), true); - } - if let Some(typed_value) = typed_value.clone() { - builder = builder.with_field("typed_value", typed_value, true); + builder = builder.with_column("value", Arc::new(value), true); } + + let typed_value = if let Some(typed_value_array) = typed_value.clone() { + let field_ref = Arc::new(Field::new( + "typed_value", + typed_value_array.data_type().clone(), + true, + )); + builder = builder.with_field(field_ref.clone(), typed_value_array.clone()); + + Some((field_ref, typed_value_array)) + } else { + None + }; + if let Some(nulls) = nulls { builder = builder.with_nulls(nulls); } @@ -345,7 +356,7 @@ impl VariantArray { pub fn value(&self, index: usize) -> Variant<'_, '_> { match (self.typed_value_field(), self.value_field()) { // Always prefer typed_value, if available - (Some(typed_value), value) if typed_value.is_valid(index) => { + (Some(typed_value), value) if typed_value.1.is_valid(index) => { typed_value_to_variant(typed_value, value, index) } // Otherwise fall back to value, if available @@ -369,8 +380,8 @@ impl VariantArray { } /// Return a reference to the typed_value field of the `StructArray`, if present - pub fn typed_value_field(&self) -> Option<&ArrayRef> { - self.shredding_state.typed_value_field() + pub fn typed_value_field(&self) -> Option<&TypedValue> { + self.shredding_state.typed_value() } /// Return a field to represent this VariantArray in a `Schema` with @@ -627,8 +638,8 @@ impl ShreddedVariantFieldArray { } /// Return a reference to the typed_value field of the `StructArray`, if present - pub fn typed_value_field(&self) -> Option<&ArrayRef> { - self.shredding_state.typed_value_field() + pub fn typed_value_field(&self) -> Option<&TypedValue> { + self.shredding_state.typed_value() } /// Returns a reference to the underlying [`StructArray`]. @@ -643,11 +654,22 @@ impl ShreddedVariantFieldArray { ) -> Self { let mut builder = StructArrayBuilder::new(); if let Some(value) = value.clone() { - builder = builder.with_field("value", Arc::new(value), true); - } - if let Some(typed_value) = typed_value.clone() { - builder = builder.with_field("typed_value", typed_value, true); + builder = builder.with_column("value", Arc::new(value), true); } + + let typed_value = if let Some(typed_value_array) = typed_value.clone() { + let field_ref = Arc::new(Field::new( + "typed_value", + typed_value_array.data_type().clone(), + true, + )); + builder = builder.with_field(field_ref.clone(), typed_value_array.clone()); + + Some((field_ref, typed_value_array)) + } else { + None + }; + if let Some(nulls) = nulls { builder = builder.with_nulls(nulls); } @@ -708,6 +730,9 @@ impl From for StructArray { } } +pub type TypedValue = (FieldRef, ArrayRef); +pub type BorrowedTypedValue<'a> = (&'a FieldRef, &'a ArrayRef); + /// Represents the shredding state of a [`VariantArray`] /// /// [`VariantArray`]s can be shredded according to the [Parquet Variant @@ -744,7 +769,7 @@ impl From for StructArray { #[derive(Debug, Clone, PartialEq)] pub struct ShreddingState { value: Option, - typed_value: Option, + typed_value: Option, } impl ShreddingState { @@ -762,7 +787,7 @@ impl ShreddingState { /// let struct_array: StructArray = get_struct_array(); /// let shredding_state = ShreddingState::try_from(&struct_array).unwrap(); /// ``` - pub fn new(value: Option, typed_value: Option) -> Self { + pub fn new(value: Option, typed_value: Option) -> Self { Self { value, typed_value } } @@ -772,7 +797,7 @@ impl ShreddingState { } /// Return a reference to the typed_value field, if present - pub fn typed_value_field(&self) -> Option<&ArrayRef> { + pub fn typed_value(&self) -> Option<&TypedValue> { self.typed_value.as_ref() } @@ -780,7 +805,7 @@ impl ShreddingState { pub fn borrow(&self) -> BorrowedShreddingState<'_> { BorrowedShreddingState { value: self.value_field(), - typed_value: self.typed_value_field(), + typed_value: self.typed_value().map(|(f, c)| (f, c)), } } @@ -788,7 +813,10 @@ impl ShreddingState { pub fn slice(&self, offset: usize, length: usize) -> Self { Self { value: self.value.as_ref().map(|v| v.slice(offset, length)), - typed_value: self.typed_value.as_ref().map(|tv| tv.slice(offset, length)), + typed_value: self + .typed_value + .as_ref() + .map(|(f, c)| (Arc::clone(f), c.slice(offset, length))), } } } @@ -798,7 +826,7 @@ impl ShreddingState { #[derive(Clone, Debug)] pub struct BorrowedShreddingState<'a> { value: Option<&'a BinaryViewArray>, - typed_value: Option<&'a ArrayRef>, + typed_value: Option>, } impl<'a> BorrowedShreddingState<'a> { @@ -816,7 +844,10 @@ impl<'a> BorrowedShreddingState<'a> { /// let struct_array: StructArray = get_struct_array(); /// let shredding_state = BorrowedShreddingState::try_from(&struct_array).unwrap(); /// ``` - pub fn new(value: Option<&'a BinaryViewArray>, typed_value: Option<&'a ArrayRef>) -> Self { + pub fn new( + value: Option<&'a BinaryViewArray>, + typed_value: Option>, + ) -> Self { Self { value, typed_value } } @@ -826,7 +857,7 @@ impl<'a> BorrowedShreddingState<'a> { } /// Return a reference to the typed_value field, if present - pub fn typed_value_field(&self) -> Option<&'a ArrayRef> { + pub fn typed_value_field(&self) -> Option> { self.typed_value } } @@ -847,7 +878,26 @@ impl<'a> TryFrom<&'a StructArray> for BorrowedShreddingState<'a> { } else { None }; - let typed_value = inner_struct.column_by_name("typed_value"); + + let typed_value = { + let typed_value_field = inner_struct + .fields() + .into_iter() + .find(|f| f.name() == "typed_value"); + + let typed_value_column = inner_struct.column_by_name("typed_value"); + + match (typed_value_field, typed_value_column) { + (Some(field), Some(col)) => Some((field, col)), + (None, None) => None, + _ => { + return Err(ArrowError::InvalidArgumentError( + "Inconsistent struct schema: 'typed_value' field and column must both exist or both be absent".into(), + )); + } + } + }; + Ok(BorrowedShreddingState::new(value, typed_value)) } } @@ -864,7 +914,9 @@ impl From> for ShreddingState { fn from(state: BorrowedShreddingState<'_>) -> Self { ShreddingState { value: state.value_field().cloned(), - typed_value: state.typed_value_field().cloned(), + typed_value: state + .typed_value_field() + .map(|(f, c)| (f.clone(), c.clone())), } } } @@ -885,13 +937,19 @@ impl StructArrayBuilder { } /// Add an array to this struct array as a field with the specified name. - pub fn with_field(mut self, field_name: &str, array: ArrayRef, nullable: bool) -> Self { + pub fn with_column(mut self, field_name: &str, array: ArrayRef, nullable: bool) -> Self { let field = Field::new(field_name, array.data_type().clone(), nullable); self.fields.push(Arc::new(field)); self.arrays.push(array); self } + pub fn with_field(mut self, field: FieldRef, array: ArrayRef) -> Self { + self.fields.push(field); + self.arrays.push(array); + self + } + /// Set the null buffer for this struct array. pub fn with_nulls(mut self, nulls: NullBuffer) -> Self { self.nulls = Some(nulls); @@ -910,70 +968,72 @@ impl StructArrayBuilder { /// returns the non-null element at index as a Variant fn typed_value_to_variant<'a>( - typed_value: &'a ArrayRef, + typed_value: &'a TypedValue, value: Option<&BinaryViewArray>, index: usize, ) -> Variant<'a, 'a> { - let data_type = typed_value.data_type(); + let (_typed_value_field, typed_value_column) = typed_value; + + let data_type = typed_value_column.data_type(); if value.is_some_and(|v| !matches!(data_type, DataType::Struct(_)) && v.is_valid(index)) { // Only a partially shredded struct is allowed to have values for both columns panic!("Invalid variant, conflicting value and typed_value"); } match data_type { DataType::Boolean => { - let boolean_array = typed_value.as_boolean(); + let boolean_array = typed_value_column.as_boolean(); let value = boolean_array.value(index); Variant::from(value) } DataType::Date32 => { - let array = typed_value.as_primitive::(); + let array = typed_value_column.as_primitive::(); let value = array.value(index); let date = Date32Type::to_naive_date(value); Variant::from(date) } // 16-byte FixedSizeBinary alway corresponds to a UUID; all other sizes are illegal. DataType::FixedSizeBinary(16) => { - let array = typed_value.as_fixed_size_binary(); + let array = typed_value_column.as_fixed_size_binary(); let value = array.value(index); Uuid::from_slice(value).unwrap().into() // unwrap is safe: slice is always 16 bytes } DataType::BinaryView => { - let array = typed_value.as_binary_view(); + let array = typed_value_column.as_binary_view(); let value = array.value(index); Variant::from(value) } DataType::Utf8 => { - let array = typed_value.as_string::(); + let array = typed_value_column.as_string::(); let value = array.value(index); Variant::from(value) } DataType::Int8 => { - primitive_conversion_single_value!(Int8Type, typed_value, index) + primitive_conversion_single_value!(Int8Type, typed_value_column, index) } DataType::Int16 => { - primitive_conversion_single_value!(Int16Type, typed_value, index) + primitive_conversion_single_value!(Int16Type, typed_value_column, index) } DataType::Int32 => { - primitive_conversion_single_value!(Int32Type, typed_value, index) + primitive_conversion_single_value!(Int32Type, typed_value_column, index) } DataType::Int64 => { - primitive_conversion_single_value!(Int64Type, typed_value, index) + primitive_conversion_single_value!(Int64Type, typed_value_column, index) } DataType::Float16 => { - primitive_conversion_single_value!(Float16Type, typed_value, index) + primitive_conversion_single_value!(Float16Type, typed_value_column, index) } DataType::Float32 => { - primitive_conversion_single_value!(Float32Type, typed_value, index) + primitive_conversion_single_value!(Float32Type, typed_value_column, index) } DataType::Float64 => { - primitive_conversion_single_value!(Float64Type, typed_value, index) + primitive_conversion_single_value!(Float64Type, typed_value_column, index) } DataType::Timestamp(TimeUnit::Microsecond, Some(_)) => { generic_conversion_single_value!( TimestampMicrosecondType, as_primitive, |v| DateTime::from_timestamp_micros(v).unwrap(), - typed_value, + typed_value_column, index ) } @@ -982,7 +1042,7 @@ fn typed_value_to_variant<'a>( TimestampMicrosecondType, as_primitive, |v| DateTime::from_timestamp_micros(v).unwrap().naive_utc(), - typed_value, + typed_value_column, index ) } @@ -991,7 +1051,7 @@ fn typed_value_to_variant<'a>( TimestampNanosecondType, as_primitive, DateTime::from_timestamp_nanos, - typed_value, + typed_value_column, index ) } @@ -1000,7 +1060,7 @@ fn typed_value_to_variant<'a>( TimestampNanosecondType, as_primitive, |v| DateTime::from_timestamp_nanos(v).naive_utc(), - typed_value, + typed_value_column, index ) } @@ -1013,7 +1073,7 @@ fn typed_value_to_variant<'a>( debug_assert!( false, "Unsupported typed_value type: {}", - typed_value.data_type() + typed_value_column.data_type() ); Variant::Null } diff --git a/parquet-variant-compute/src/variant_get.rs b/parquet-variant-compute/src/variant_get.rs index e782b5968af5..208eacb19231 100644 --- a/parquet-variant-compute/src/variant_get.rs +++ b/parquet-variant-compute/src/variant_get.rs @@ -59,7 +59,7 @@ pub(crate) fn follow_shredded_path_element<'a>( None => ShreddedPathStep::Missing, }; - let Some(typed_value) = shredding_state.typed_value_field() else { + let Some((_, typed_value_col)) = shredding_state.typed_value_field() else { return Ok(missing_path_step()); }; @@ -67,13 +67,13 @@ pub(crate) fn follow_shredded_path_element<'a>( VariantPathElement::Field { name } => { // Try to step into the requested field name of a struct. // First, try to downcast to StructArray - let Some(struct_array) = typed_value.as_any().downcast_ref::() else { + let Some(struct_array) = typed_value_col.as_any().downcast_ref::() else { // Downcast failure - if strict cast options are enabled, this should be an error if !cast_options.safe { return Err(ArrowError::CastError(format!( "Cannot access field '{}' on non-struct type: {}", name, - typed_value.data_type() + typed_value_col.data_type() ))); } // With safe cast options, return NULL (missing_path_step) @@ -158,10 +158,10 @@ fn shredded_get_path( match follow_shredded_path_element(&shredding_state, path_element, cast_options)? { ShreddedPathStep::Success(state) => { // Union nulls from the typed_value we just accessed - if let Some(typed_value) = shredding_state.typed_value_field() { + if let Some((_, typed_value_column)) = shredding_state.typed_value_field() { accumulated_nulls = arrow::buffer::NullBuffer::union( accumulated_nulls.as_ref(), - typed_value.nulls(), + typed_value_column.nulls(), ); } shredding_state = state; @@ -190,7 +190,7 @@ fn shredded_get_path( // Path exhausted! Create a new `VariantArray` for the location we landed on. let target = make_target_variant( shredding_state.value_field().cloned(), - shredding_state.typed_value_field().cloned(), + shredding_state.typed_value_field().map(|(_, c)| c).cloned(), accumulated_nulls, ); @@ -450,9 +450,9 @@ mod test { let typed_value = $typed_value_array_gen(); let struct_array = StructArrayBuilder::new() - .with_field("metadata", Arc::new(metadata), false) - .with_field("typed_value", Arc::new(typed_value), true) - .with_field("value", Arc::new(values), true) + .with_column("metadata", Arc::new(metadata), false) + .with_column("typed_value", Arc::new(typed_value), true) + .with_column("value", Arc::new(values), true) .with_nulls(nulls) .build(); ArrayRef::from( @@ -778,8 +778,8 @@ mod test { let typed_value = $typed_value_gen(); let struct_array = StructArrayBuilder::new() - .with_field("metadata", Arc::new(metadata), false) - .with_field("typed_value", Arc::new(typed_value), true) + .with_column("metadata", Arc::new(metadata), false) + .with_column("typed_value", Arc::new(typed_value), true) .build(); VariantArray::try_new(&struct_array) @@ -1186,9 +1186,9 @@ mod test { let typed_value = $typed_array_gen(); let struct_array = StructArrayBuilder::new() - .with_field("metadata", Arc::new(metadata), false) - .with_field("typed_value", Arc::new(typed_value), true) - .with_field("value", Arc::new(values), true) + .with_column("metadata", Arc::new(metadata), false) + .with_column("typed_value", Arc::new(typed_value), true) + .with_column("value", Arc::new(values), true) .with_nulls(nulls) .build(); @@ -1285,7 +1285,7 @@ mod test { BinaryViewArray::from_iter_values(std::iter::repeat_n(EMPTY_VARIANT_METADATA_BYTES, 3)); let struct_array = StructArrayBuilder::new() - .with_field("metadata", Arc::new(metadata), false) + .with_column("metadata", Arc::new(metadata), false) .with_nulls(nulls) .build(); @@ -1375,7 +1375,7 @@ mod test { // For perfect shredding of the x field, no "value" column, only typed_value let x_field_struct = StructArrayBuilder::new() - .with_field("typed_value", Arc::new(x_field_typed_value), true) + .with_column("typed_value", Arc::new(x_field_typed_value), true) .build(); // Wrap the x field struct in a ShreddedVariantFieldArray @@ -1397,9 +1397,9 @@ mod test { // Create the main VariantArray let main_struct = StructArrayBuilder::new() - .with_field("metadata", Arc::new(metadata_array), false) - .with_field("value", Arc::new(value_array), true) - .with_field("typed_value", Arc::new(typed_value_struct), true) + .with_column("metadata", Arc::new(metadata_array), false) + .with_column("value", Arc::new(value_array), true) + .with_column("typed_value", Arc::new(typed_value_struct), true) .build(); Arc::new(main_struct) @@ -1755,7 +1755,7 @@ mod test { // For the x field, only typed_value (perfect shredding when possible) let x_field_struct = StructArrayBuilder::new() - .with_field("typed_value", Arc::new(x_field_typed_value), true) + .with_column("typed_value", Arc::new(x_field_typed_value), true) .build(); let x_field_shredded = ShreddedVariantFieldArray::try_new(&x_field_struct) @@ -1776,9 +1776,9 @@ mod test { // Build final VariantArray let struct_array = StructArrayBuilder::new() - .with_field("metadata", Arc::new(metadata_array), false) - .with_field("value", Arc::new(value_array), true) - .with_field("typed_value", Arc::new(typed_value_struct), true) + .with_column("metadata", Arc::new(metadata_array), false) + .with_column("value", Arc::new(value_array), true) + .with_column("typed_value", Arc::new(typed_value_struct), true) .build(); Arc::new(struct_array) @@ -1837,7 +1837,7 @@ mod test { // Level 2: x field (the deepest level) let x_typed_value = Int32Array::from(vec![Some(55), None]); let x_field_struct = StructArrayBuilder::new() - .with_field("typed_value", Arc::new(x_typed_value), true) + .with_column("typed_value", Arc::new(x_typed_value), true) .build(); let x_field_shredded = ShreddedVariantFieldArray::try_new(&x_field_struct) .expect("should create ShreddedVariantFieldArray for x"); @@ -1864,7 +1864,7 @@ mod test { true, )]); let a_inner_struct = StructArrayBuilder::new() - .with_field( + .with_column( "typed_value", Arc::new( StructArray::try_new( @@ -1876,7 +1876,7 @@ mod test { ), true, ) - .with_field("value", Arc::new(a_value_array), true) + .with_column("value", Arc::new(a_value_array), true) .build(); let a_field_shredded = ShreddedVariantFieldArray::try_new(&a_inner_struct) .expect("should create ShreddedVariantFieldArray for a"); @@ -1896,9 +1896,9 @@ mod test { // Build final VariantArray let struct_array = StructArrayBuilder::new() - .with_field("metadata", Arc::new(metadata_array), false) - .with_field("value", Arc::new(value_array), true) - .with_field("typed_value", Arc::new(typed_value_struct), true) + .with_column("metadata", Arc::new(metadata_array), false) + .with_column("value", Arc::new(value_array), true) + .with_column("typed_value", Arc::new(typed_value_struct), true) .build(); Arc::new(struct_array) @@ -1950,7 +1950,7 @@ mod test { // Level 3: x field (deepest level) let x_typed_value = Int32Array::from(vec![Some(100), None, None]); let x_field_struct = StructArrayBuilder::new() - .with_field("typed_value", Arc::new(x_typed_value), true) + .with_column("typed_value", Arc::new(x_typed_value), true) .build(); let x_field_shredded = ShreddedVariantFieldArray::try_new(&x_field_struct) .expect("should create ShreddedVariantFieldArray for x"); @@ -1975,7 +1975,7 @@ mod test { true, )]); let b_inner_struct = StructArrayBuilder::new() - .with_field( + .with_column( "typed_value", Arc::new( StructArray::try_new( @@ -1987,7 +1987,7 @@ mod test { ), true, ) - .with_field("value", Arc::new(b_value_array), true) + .with_column("value", Arc::new(b_value_array), true) .build(); let b_field_shredded = ShreddedVariantFieldArray::try_new(&b_inner_struct) .expect("should create ShreddedVariantFieldArray for b"); @@ -2012,7 +2012,7 @@ mod test { true, )]); let a_inner_struct = StructArrayBuilder::new() - .with_field( + .with_column( "typed_value", Arc::new( StructArray::try_new( @@ -2024,7 +2024,7 @@ mod test { ), true, ) - .with_field("value", Arc::new(a_value_array), true) + .with_column("value", Arc::new(a_value_array), true) .build(); let a_field_shredded = ShreddedVariantFieldArray::try_new(&a_inner_struct) .expect("should create ShreddedVariantFieldArray for a"); @@ -2044,9 +2044,9 @@ mod test { // Build final VariantArray let struct_array = StructArrayBuilder::new() - .with_field("metadata", Arc::new(metadata_array), false) - .with_field("value", Arc::new(value_array), true) - .with_field("typed_value", Arc::new(typed_value_struct), true) + .with_column("metadata", Arc::new(metadata_array), false) + .with_column("value", Arc::new(value_array), true) + .with_column("typed_value", Arc::new(typed_value_struct), true) .build(); Arc::new(struct_array) @@ -2736,7 +2736,7 @@ mod test { // Field "a": present in rows 0,3 (missing in rows 1,2,4) let a_field_typed_value = Int32Array::from(vec![Some(1), None, None, Some(1), None]); let a_field_struct = StructArrayBuilder::new() - .with_field("typed_value", Arc::new(a_field_typed_value), true) + .with_column("typed_value", Arc::new(a_field_typed_value), true) .build(); let a_field_shredded = ShreddedVariantFieldArray::try_new(&a_field_struct) .expect("should create ShreddedVariantFieldArray for a"); @@ -2744,7 +2744,7 @@ mod test { // Field "b": present in rows 0,2 (missing in rows 1,3,4) let b_field_typed_value = Int32Array::from(vec![Some(2), None, Some(2), None, None]); let b_field_struct = StructArrayBuilder::new() - .with_field("typed_value", Arc::new(b_field_typed_value), true) + .with_column("typed_value", Arc::new(b_field_typed_value), true) .build(); let b_field_shredded = ShreddedVariantFieldArray::try_new(&b_field_struct) .expect("should create ShreddedVariantFieldArray for b"); @@ -2752,7 +2752,7 @@ mod test { // Field "c": present in row 0 only (missing in all other rows) let c_field_typed_value = Int32Array::from(vec![Some(3), None, None, None, None]); let c_field_struct = StructArrayBuilder::new() - .with_field("typed_value", Arc::new(c_field_typed_value), true) + .with_column("typed_value", Arc::new(c_field_typed_value), true) .build(); let c_field_shredded = ShreddedVariantFieldArray::try_new(&c_field_struct) .expect("should create ShreddedVariantFieldArray for c"); @@ -2776,8 +2776,8 @@ mod test { // Build final VariantArray with top-level nulls let struct_array = StructArrayBuilder::new() - .with_field("metadata", Arc::new(metadata_array), false) - .with_field("typed_value", Arc::new(typed_value_struct), true) + .with_column("metadata", Arc::new(metadata_array), false) + .with_column("typed_value", Arc::new(typed_value_struct), true) .with_nulls(nulls) .build(); @@ -2793,7 +2793,7 @@ mod test { // Row 0: has value 42, Row 1: inner null, Row 2: outer null, Row 3: top-level null let inner_typed_value = Int32Array::from(vec![Some(42), None, None, None]); // dummy value for row 2 let inner = StructArrayBuilder::new() - .with_field("typed_value", Arc::new(inner_typed_value), true) + .with_column("typed_value", Arc::new(inner_typed_value), true) .build(); let inner = ShreddedVariantFieldArray::try_new(&inner).unwrap(); @@ -2804,12 +2804,12 @@ mod test { false, // row 3: top-level NULL ]); let outer_typed_value = StructArrayBuilder::new() - .with_field("inner", ArrayRef::from(inner), false) + .with_column("inner", ArrayRef::from(inner), false) .with_nulls(outer_typed_value_nulls) .build(); let outer = StructArrayBuilder::new() - .with_field("typed_value", Arc::new(outer_typed_value), true) + .with_column("typed_value", Arc::new(outer_typed_value), true) .build(); let outer = ShreddedVariantFieldArray::try_new(&outer).unwrap(); @@ -2820,7 +2820,7 @@ mod test { false, // row 3: top-level NULL ]); let typed_value = StructArrayBuilder::new() - .with_field("outer", ArrayRef::from(outer), false) + .with_column("outer", ArrayRef::from(outer), false) .with_nulls(typed_value_nulls) .build(); @@ -2834,8 +2834,8 @@ mod test { false, // row 3: top-level NULL ]); let struct_array = StructArrayBuilder::new() - .with_field("metadata", Arc::new(metadata_array), false) - .with_field("typed_value", Arc::new(typed_value), true) + .with_column("metadata", Arc::new(metadata_array), false) + .with_column("typed_value", Arc::new(typed_value), true) .with_nulls(nulls) .build(); @@ -2890,23 +2890,23 @@ mod test { // For top-level null row, the field still needs valid content (not null) let x_field_typed_value = Int32Array::from(vec![Some(1), Some(2), Some(3), Some(0)]); let x_field_struct = StructArrayBuilder::new() - .with_field("typed_value", Arc::new(x_field_typed_value), true) + .with_column("typed_value", Arc::new(x_field_typed_value), true) .build(); let x_field_shredded = ShreddedVariantFieldArray::try_new(&x_field_struct) .expect("should create ShreddedVariantFieldArray for x"); // Create main typed_value struct (only contains shredded fields) let typed_value_struct = StructArrayBuilder::new() - .with_field("x", ArrayRef::from(x_field_shredded), false) + .with_column("x", ArrayRef::from(x_field_shredded), false) .build(); // Build VariantArray with both value and typed_value (PartiallyShredded) // Top-level null is encoded in the main StructArray's null mask let variant_nulls = NullBuffer::from(vec![true, true, true, false]); // Row 3 is top-level null let struct_array = StructArrayBuilder::new() - .with_field("metadata", Arc::new(metadata_array), false) - .with_field("value", Arc::new(value_array), true) - .with_field("typed_value", Arc::new(typed_value_struct), true) + .with_column("metadata", Arc::new(metadata_array), false) + .with_column("value", Arc::new(value_array), true) + .with_column("typed_value", Arc::new(typed_value_struct), true) .with_nulls(variant_nulls) .build();