From b8088ba18ea5785a2994028509d34546a8640eeb Mon Sep 17 00:00:00 2001 From: Joe Isaacs Date: Wed, 11 Mar 2026 18:57:43 +0000 Subject: [PATCH 1/5] ci: add _extends and pinned arm64 AMI to runs-on config RunsOn reads config from the default branch (develop) for public repos. Add _extends to inherit runner config from .github-private and pin arm64 AMI for prebuilt image testing. Co-Authored-By: Claude Opus 4.6 --- .github/runs-on.yml | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-) diff --git a/.github/runs-on.yml b/.github/runs-on.yml index 29bdf810fda..6a904a6a10d 100644 --- a/.github/runs-on.yml +++ b/.github/runs-on.yml @@ -1,11 +1,6 @@ +_extends: .github-private images: - vortex-ci-amd64: - platform: "linux" - arch: "x64" - name: "vortex-ci-*" - owner: "245040174862" - vortex-ci-arm64: + ubuntu24-full-arm64-pre: platform: "linux" arch: "arm64" - name: "vortex-ci-*" - owner: "245040174862" + ami: "ami-08f97c6362847dc5d" From f27e9978915d1025228b9750372441660cd714ce Mon Sep 17 00:00:00 2001 From: Joe Isaacs Date: Tue, 28 Apr 2026 11:31:18 +0100 Subject: [PATCH 2/5] fix Signed-off-by: Joe Isaacs --- vortex-array/src/arrays/masked/execute.rs | 124 ++++++------------- vortex-array/src/arrays/masked/vtable/mod.rs | 13 +- vortex-array/src/scalar_fn/fns/mask/mod.rs | 8 +- 3 files changed, 46 insertions(+), 99 deletions(-) diff --git a/vortex-array/src/arrays/masked/execute.rs b/vortex-array/src/arrays/masked/execute.rs index 4bc6449ead3..8886a56a017 100644 --- a/vortex-array/src/arrays/masked/execute.rs +++ b/vortex-array/src/arrays/masked/execute.rs @@ -3,11 +3,9 @@ //! Execution logic for MaskedArray - applies a validity mask to canonical arrays. -use std::ops::BitAnd; use std::sync::Arc; use vortex_error::VortexResult; -use vortex_mask::Mask; use crate::Canonical; use crate::IntoArray; @@ -17,7 +15,6 @@ use crate::arrays::ExtensionArray; use crate::arrays::FixedSizeListArray; use crate::arrays::ListViewArray; use crate::arrays::MaskedArray; -use crate::arrays::NullArray; use crate::arrays::PrimitiveArray; use crate::arrays::StructArray; use crate::arrays::VarBinViewArray; @@ -28,7 +25,6 @@ use crate::arrays::fixed_size_list::FixedSizeListArrayExt; use crate::arrays::listview::ListViewArrayExt; use crate::arrays::struct_::StructArrayExt; use crate::arrays::variant::VariantArrayExt; -use crate::dtype::Nullability; use crate::executor::ExecutionCtx; use crate::match_each_decimal_value_type; use crate::validity::Validity; @@ -40,64 +36,36 @@ use crate::validity::Validity; /// validity with the provided mask, marking additional positions as invalid. pub fn mask_validity_canonical( canonical: Canonical, - validity_mask: &Mask, + validity: Validity, ctx: &mut ExecutionCtx, ) -> VortexResult { Ok(match canonical { - Canonical::Null(a) => Canonical::Null(mask_validity_null(a, validity_mask)), - Canonical::Bool(a) => Canonical::Bool(mask_validity_bool(a, validity_mask, ctx)?), - Canonical::Primitive(a) => { - Canonical::Primitive(mask_validity_primitive(a, validity_mask, ctx)?) - } - Canonical::Decimal(a) => Canonical::Decimal(mask_validity_decimal(a, validity_mask, ctx)?), - Canonical::VarBinView(a) => { - Canonical::VarBinView(mask_validity_varbinview(a, validity_mask, ctx)?) - } - Canonical::List(a) => Canonical::List(mask_validity_listview(a, validity_mask, ctx)?), + n @ Canonical::Null(_) => n, + Canonical::Bool(a) => Canonical::Bool(mask_validity_bool(a, validity)?), + Canonical::Primitive(a) => Canonical::Primitive(mask_validity_primitive(a, validity)?), + Canonical::Decimal(a) => Canonical::Decimal(mask_validity_decimal(a, validity)?), + Canonical::VarBinView(a) => Canonical::VarBinView(mask_validity_varbinview(a, validity)?), + Canonical::List(a) => Canonical::List(mask_validity_listview(a, validity)?), Canonical::FixedSizeList(a) => { - Canonical::FixedSizeList(mask_validity_fixed_size_list(a, validity_mask, ctx)?) - } - Canonical::Struct(a) => Canonical::Struct(mask_validity_struct(a, validity_mask, ctx)?), - Canonical::Extension(a) => { - Canonical::Extension(mask_validity_extension(a, validity_mask, ctx)?) + Canonical::FixedSizeList(mask_validity_fixed_size_list(a, validity)?) } - Canonical::Variant(a) => Canonical::Variant(mask_validity_variant(a, validity_mask, ctx)?), + Canonical::Struct(a) => Canonical::Struct(mask_validity_struct(a, validity)?), + Canonical::Extension(a) => Canonical::Extension(mask_validity_extension(a, validity, ctx)?), + Canonical::Variant(a) => Canonical::Variant(mask_validity_variant(a, validity)?), }) } -fn combine_validity( - validity: &Validity, - mask: &Mask, - len: usize, - ctx: &mut ExecutionCtx, -) -> VortexResult { - let current_mask = validity.execute_mask(len, ctx)?; - let combined = current_mask.bitand(mask); - Ok(Validity::from_mask(combined, Nullability::Nullable)) -} - -fn mask_validity_null(array: NullArray, _mask: &Mask) -> NullArray { - array -} - -fn mask_validity_bool( - array: BoolArray, - mask: &Mask, - ctx: &mut ExecutionCtx, -) -> VortexResult { - let len = array.len(); - let new_validity = combine_validity(&array.validity()?, mask, len, ctx)?; +fn mask_validity_bool(array: BoolArray, mask: Validity) -> VortexResult { + let new_validity = Validity::and(array.validity()?, mask)?; Ok(BoolArray::new(array.to_bit_buffer(), new_validity)) } fn mask_validity_primitive( array: PrimitiveArray, - mask: &Mask, - ctx: &mut ExecutionCtx, + validity: Validity, ) -> VortexResult { - let len = array.len(); let ptype = array.ptype(); - let new_validity = combine_validity(&array.validity()?, mask, len, ctx)?; + let new_validity = Validity::and(array.validity()?, validity)?; // SAFETY: validity has same length as values Ok(unsafe { PrimitiveArray::new_unchecked_from_handle( @@ -108,31 +76,30 @@ fn mask_validity_primitive( }) } -fn mask_validity_decimal( - array: DecimalArray, - mask: &Mask, - ctx: &mut ExecutionCtx, -) -> VortexResult { - let len = array.len(); - let dec_dtype = array.decimal_dtype(); +fn mask_validity_decimal(array: DecimalArray, validity: Validity) -> VortexResult { let values_type = array.values_type(); - let new_validity = combine_validity(&array.validity()?, mask, len, ctx)?; + let new_validity = Validity::and(array.validity()?, validity)?; // SAFETY: We're only changing validity, not the data structure Ok(match_each_decimal_value_type!(values_type, |T| { let buffer = array.buffer::(); - unsafe { DecimalArray::new_unchecked(buffer, dec_dtype, new_validity) } + unsafe { + DecimalArray::new_unchecked_handle( + array.buffer_handle().clone(), + array.values_type(), + array.decimal_dtype(), + new_validity, + ) + } })) } /// Mask validity for VarBinViewArray. fn mask_validity_varbinview( array: VarBinViewArray, - mask: &Mask, - ctx: &mut ExecutionCtx, + validity: Validity, ) -> VortexResult { - let len = array.len(); let dtype = array.dtype().as_nullable(); - let new_validity = combine_validity(&array.validity()?, mask, len, ctx)?; + let new_validity = Validity::and(array.validity()?, validity)?; // SAFETY: We're only changing validity, not the data structure Ok(unsafe { VarBinViewArray::new_handle_unchecked( @@ -144,13 +111,8 @@ fn mask_validity_varbinview( }) } -fn mask_validity_listview( - array: ListViewArray, - mask: &Mask, - ctx: &mut ExecutionCtx, -) -> VortexResult { - let len = array.len(); - let new_validity = combine_validity(&array.validity()?, mask, len, ctx)?; +fn mask_validity_listview(array: ListViewArray, validity: Validity) -> VortexResult { + let new_validity = Validity::and(array.validity()?, validity)?; // SAFETY: We're only changing validity, not the data structure Ok(unsafe { ListViewArray::new_unchecked( @@ -164,25 +126,20 @@ fn mask_validity_listview( fn mask_validity_fixed_size_list( array: FixedSizeListArray, - mask: &Mask, - ctx: &mut ExecutionCtx, + validity: Validity, ) -> VortexResult { let len = array.len(); let list_size = array.list_size(); - let new_validity = combine_validity(&array.validity()?, mask, len, ctx)?; + let new_validity = Validity::and(array.validity()?, validity)?; // SAFETY: We're only changing validity, not the data structure Ok(unsafe { FixedSizeListArray::new_unchecked(array.elements().clone(), list_size, new_validity, len) }) } -fn mask_validity_struct( - array: StructArray, - mask: &Mask, - ctx: &mut ExecutionCtx, -) -> VortexResult { +fn mask_validity_struct(array: StructArray, validity: Validity) -> VortexResult { let len = array.len(); - let new_validity = combine_validity(&array.validity()?, mask, len, ctx)?; + let new_validity = Validity::and(array.validity()?, validity)?; let fields = array.unmasked_fields(); let struct_fields = array.struct_fields(); // SAFETY: We're only changing validity, not the data structure @@ -191,12 +148,12 @@ fn mask_validity_struct( fn mask_validity_extension( array: ExtensionArray, - mask: &Mask, + validity: Validity, ctx: &mut ExecutionCtx, ) -> VortexResult { // For extension arrays, we need to mask the underlying storage let storage = array.storage_array().clone().execute::(ctx)?; - let masked_storage = mask_validity_canonical(storage, mask, ctx)?; + let masked_storage = mask_validity_canonical(storage, validity, ctx)?; let masked_storage = masked_storage.into_array(); Ok(ExtensionArray::new( array @@ -206,11 +163,7 @@ fn mask_validity_extension( )) } -fn mask_validity_variant( - array: VariantArray, - mask: &Mask, - ctx: &mut ExecutionCtx, -) -> VortexResult { +fn mask_validity_variant(array: VariantArray, validity: Validity) -> VortexResult { let child = array.child().clone(); let len = child.len(); let child_validity = child.validity()?; @@ -218,8 +171,7 @@ fn mask_validity_variant( match child_validity { Validity::NonNullable | Validity::AllValid => { // Child has no nulls — wrap in MaskedArray to apply the mask. - let new_validity = Validity::from_mask(mask.clone(), Nullability::Nullable); - let masked_child = MaskedArray::try_new(child, new_validity)?; + let masked_child = MaskedArray::try_new(child, validity)?; Ok(VariantArray::new(masked_child.into_array())) } Validity::AllInvalid => { @@ -229,7 +181,7 @@ fn mask_validity_variant( Validity::Array(_) => { // Child has an array-backed validity stored as its first child. // Combine with the mask and replace that child via with_children. - let combined = combine_validity(&child_validity, mask, len, ctx)?; + let combined = Validity::and(child_validity, validity)?; let new_child = child.with_slot(0, combined.to_array(len))?; Ok(VariantArray::new(new_child)) } diff --git a/vortex-array/src/arrays/masked/vtable/mod.rs b/vortex-array/src/arrays/masked/vtable/mod.rs index d4eb457c434..9348f13c695 100644 --- a/vortex-array/src/arrays/masked/vtable/mod.rs +++ b/vortex-array/src/arrays/masked/vtable/mod.rs @@ -33,7 +33,6 @@ use crate::arrays::masked::MaskedArrayExt; use crate::arrays::masked::MaskedData; use crate::arrays::masked::array::CHILD_SLOT; use crate::arrays::masked::array::SLOT_NAMES; -use crate::arrays::masked::array::VALIDITY_SLOT; use crate::arrays::masked::compute::rules::PARENT_RULES; use crate::arrays::masked::mask_validity_canonical; use crate::buffer::BufferHandle; @@ -41,7 +40,6 @@ use crate::dtype::DType; use crate::executor::ExecutionCtx; use crate::executor::ExecutionResult; use crate::require_child; -use crate::require_validity; use crate::scalar::Scalar; use crate::serde::ArrayChildren; use crate::validity::Validity; @@ -161,10 +159,12 @@ impl VTable for Masked { } fn execute(array: Array, ctx: &mut ExecutionCtx) -> VortexResult { - let validity_mask = array.masked_validity().execute_mask(array.len(), ctx)?; + let array = require_child!(array, array.child(), CHILD_SLOT => AnyCanonical); + + let validity = array.masked_validity(); // Fast path: all masked means result is all nulls. - if validity_mask.all_false() { + if matches!(validity, Validity::AllInvalid) { return Ok(ExecutionResult::done( ConstantArray::new(Scalar::null(array.dtype().as_nullable()), array.len()) .into_array(), @@ -177,12 +177,9 @@ impl VTable for Masked { // While we could manually convert the dtype, `mask_validity_canonical` is already O(1) for // `AllTrue` masks (no data copying), so there's no benefit. - let array = require_child!(array, array.child(), CHILD_SLOT => AnyCanonical); - require_validity!(array, VALIDITY_SLOT); - let child = Canonical::from(array.child().as_::()); Ok(ExecutionResult::done( - mask_validity_canonical(child, &validity_mask, ctx)?.into_array(), + mask_validity_canonical(child, validity, ctx)?.into_array(), )) } diff --git a/vortex-array/src/scalar_fn/fns/mask/mod.rs b/vortex-array/src/scalar_fn/fns/mask/mod.rs index cce76412fa6..e70b032390f 100644 --- a/vortex-array/src/scalar_fn/fns/mask/mod.rs +++ b/vortex-array/src/scalar_fn/fns/mask/mod.rs @@ -14,12 +14,12 @@ use crate::ArrayRef; use crate::Canonical; use crate::ExecutionCtx; use crate::IntoArray; -use crate::arrays::BoolArray; use crate::arrays::Constant; use crate::arrays::ConstantArray; use crate::arrays::bool::BoolArrayExt; use crate::arrays::masked::mask_validity_canonical; use crate::builtins::ArrayBuiltins; +use crate::child_to_validity; use crate::dtype::DType; use crate::dtype::Nullability; use crate::expr::Expression; @@ -182,11 +182,9 @@ fn execute_canonical( mask_array: ArrayRef, ctx: &mut ExecutionCtx, ) -> VortexResult { - let mask_bool = mask_array.execute::(ctx)?; - let validity_mask = vortex_mask::Mask::from(mask_bool.to_bit_buffer()); - + let validity = child_to_validity(&Some(mask_array), Nullability::Nullable); let canonical = input.execute::(ctx)?; - Ok(mask_validity_canonical(canonical, &validity_mask, ctx)?.into_array()) + Ok(mask_validity_canonical(canonical, validity, ctx)?.into_array()) } #[cfg(test)] From 2d72d7f905d6e029ba1165b9ce18a3b7adb85ee6 Mon Sep 17 00:00:00 2001 From: Joe Isaacs Date: Tue, 28 Apr 2026 12:01:52 +0100 Subject: [PATCH 3/5] fix Signed-off-by: Joe Isaacs --- vortex-array/src/arrays/masked/array.rs | 33 +++++++------------ .../src/arrays/masked/compute/filter.rs | 2 +- .../src/arrays/masked/compute/mask.rs | 2 +- .../src/arrays/masked/compute/slice.rs | 2 +- .../src/arrays/masked/compute/take.rs | 2 +- vortex-array/src/arrays/masked/mod.rs | 2 ++ vortex-array/src/arrays/masked/vtable/mod.rs | 12 +++---- .../src/arrays/masked/vtable/operations.rs | 2 +- 8 files changed, 24 insertions(+), 33 deletions(-) diff --git a/vortex-array/src/arrays/masked/array.rs b/vortex-array/src/arrays/masked/array.rs index 54924f8053f..5253156d1fb 100644 --- a/vortex-array/src/arrays/masked/array.rs +++ b/vortex-array/src/arrays/masked/array.rs @@ -4,7 +4,6 @@ use std::fmt::Display; use std::fmt::Formatter; -use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; @@ -16,15 +15,17 @@ use crate::array::ArrayParts; use crate::array::TypedArrayRef; use crate::array::child_to_validity; use crate::array::validity_to_child; +use crate::array_slots; use crate::arrays::Masked; use crate::validity::Validity; -/// The underlying child array being masked. -pub(super) const CHILD_SLOT: usize = 0; -/// The validity bitmap defining which elements are non-null. -pub(super) const VALIDITY_SLOT: usize = 1; -pub(super) const NUM_SLOTS: usize = 2; -pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["child", "validity"]; +#[array_slots(Masked)] +pub struct MaskedSlots { + /// The underlying child array being masked. + pub child: ArrayRef, + /// The validity bitmap defining which elements are non-null. + pub validity: Option, +} #[derive(Clone, Debug)] pub struct MaskedData; @@ -35,22 +36,10 @@ impl Display for MaskedData { } } -pub trait MaskedArrayExt: TypedArrayRef { - fn child(&self) -> &ArrayRef { - self.as_ref().slots()[CHILD_SLOT] - .as_ref() - .vortex_expect("validated masked child slot") - } - - fn validity_child(&self) -> Option<&ArrayRef> { - self.as_ref().slots()[VALIDITY_SLOT].as_ref() - } - +pub trait MaskedArrayExt: TypedArrayRef + MaskedArraySlotsExt { fn masked_validity(&self) -> Validity { - child_to_validity( - &self.as_ref().slots()[VALIDITY_SLOT], - self.as_ref().dtype().nullability(), - ) + let x = &self.as_ref().slots()[MaskedSlots::VALIDITY]; + child_to_validity(x, self.as_ref().dtype().nullability()) } } impl> MaskedArrayExt for T {} diff --git a/vortex-array/src/arrays/masked/compute/filter.rs b/vortex-array/src/arrays/masked/compute/filter.rs index fb3969b4bb8..9ea6b168105 100644 --- a/vortex-array/src/arrays/masked/compute/filter.rs +++ b/vortex-array/src/arrays/masked/compute/filter.rs @@ -10,7 +10,7 @@ use crate::array::ArrayView; use crate::arrays::Masked; use crate::arrays::MaskedArray; use crate::arrays::filter::FilterReduce; -use crate::arrays::masked::MaskedArrayExt; +use crate::arrays::masked::MaskedArraySlotsExt; impl FilterReduce for Masked { fn filter(array: ArrayView<'_, Masked>, mask: &Mask) -> VortexResult> { diff --git a/vortex-array/src/arrays/masked/compute/mask.rs b/vortex-array/src/arrays/masked/compute/mask.rs index d8590a68d34..514d0aeaafc 100644 --- a/vortex-array/src/arrays/masked/compute/mask.rs +++ b/vortex-array/src/arrays/masked/compute/mask.rs @@ -6,7 +6,7 @@ use vortex_error::VortexResult; use crate::ArrayRef; use crate::array::ArrayView; use crate::arrays::Masked; -use crate::arrays::masked::MaskedArrayExt; +use crate::arrays::masked::MaskedArraySlotsExt; use crate::arrays::scalar_fn::ScalarFnFactoryExt; use crate::scalar_fn::EmptyOptions; use crate::scalar_fn::fns::mask::Mask as MaskExpr; diff --git a/vortex-array/src/arrays/masked/compute/slice.rs b/vortex-array/src/arrays/masked/compute/slice.rs index fe295bd6826..5a51ca9f681 100644 --- a/vortex-array/src/arrays/masked/compute/slice.rs +++ b/vortex-array/src/arrays/masked/compute/slice.rs @@ -10,7 +10,7 @@ use crate::IntoArray; use crate::array::ArrayView; use crate::arrays::Masked; use crate::arrays::MaskedArray; -use crate::arrays::masked::MaskedArrayExt; +use crate::arrays::masked::MaskedArraySlotsExt; use crate::arrays::slice::SliceReduce; impl SliceReduce for Masked { diff --git a/vortex-array/src/arrays/masked/compute/take.rs b/vortex-array/src/arrays/masked/compute/take.rs index 958a848d180..1eff686b4d9 100644 --- a/vortex-array/src/arrays/masked/compute/take.rs +++ b/vortex-array/src/arrays/masked/compute/take.rs @@ -9,7 +9,7 @@ use crate::array::ArrayView; use crate::arrays::Masked; use crate::arrays::MaskedArray; use crate::arrays::dict::TakeReduce; -use crate::arrays::masked::MaskedArrayExt; +use crate::arrays::masked::MaskedArraySlotsExt; use crate::builtins::ArrayBuiltins; use crate::scalar::Scalar; use crate::validity::Validity; diff --git a/vortex-array/src/arrays/masked/mod.rs b/vortex-array/src/arrays/masked/mod.rs index ac437d30321..7e23653c1c4 100644 --- a/vortex-array/src/arrays/masked/mod.rs +++ b/vortex-array/src/arrays/masked/mod.rs @@ -3,7 +3,9 @@ mod array; pub use array::MaskedArrayExt; +pub use array::MaskedArraySlotsExt; pub use array::MaskedData; +pub use array::MaskedSlots; pub use vtable::MaskedArray; pub(crate) mod compute; diff --git a/vortex-array/src/arrays/masked/vtable/mod.rs b/vortex-array/src/arrays/masked/vtable/mod.rs index 9348f13c695..2ef10ba0082 100644 --- a/vortex-array/src/arrays/masked/vtable/mod.rs +++ b/vortex-array/src/arrays/masked/vtable/mod.rs @@ -30,9 +30,9 @@ use crate::array::VTable; use crate::array::validity_to_child; use crate::arrays::ConstantArray; use crate::arrays::masked::MaskedArrayExt; +use crate::arrays::masked::MaskedArraySlotsExt; use crate::arrays::masked::MaskedData; -use crate::arrays::masked::array::CHILD_SLOT; -use crate::arrays::masked::array::SLOT_NAMES; +use crate::arrays::masked::array::MaskedSlots; use crate::arrays::masked::compute::rules::PARENT_RULES; use crate::arrays::masked::mask_validity_canonical; use crate::buffer::BufferHandle; @@ -78,10 +78,10 @@ impl VTable for Masked { slots: &[Option], ) -> VortexResult<()> { vortex_ensure!( - slots[CHILD_SLOT].is_some(), + slots[MaskedSlots::CHILD].is_some(), "MaskedArray child slot must be present" ); - let child = slots[CHILD_SLOT] + let child = slots[MaskedSlots::CHILD] .as_ref() .vortex_expect("validated child slot"); vortex_ensure!(child.len() == len, "MaskedArray child length mismatch"); @@ -159,7 +159,7 @@ impl VTable for Masked { } fn execute(array: Array, ctx: &mut ExecutionCtx) -> VortexResult { - let array = require_child!(array, array.child(), CHILD_SLOT => AnyCanonical); + let array = require_child!(array, array.child(), MaskedSlots::CHILD => AnyCanonical); let validity = array.masked_validity(); @@ -191,7 +191,7 @@ impl VTable for Masked { PARENT_RULES.evaluate(array, parent, child_idx) } fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String { - SLOT_NAMES[idx].to_string() + MaskedSlots::NAMES[idx].to_string() } } diff --git a/vortex-array/src/arrays/masked/vtable/operations.rs b/vortex-array/src/arrays/masked/vtable/operations.rs index 294cd840376..c82d0bf03ed 100644 --- a/vortex-array/src/arrays/masked/vtable/operations.rs +++ b/vortex-array/src/arrays/masked/vtable/operations.rs @@ -7,7 +7,7 @@ use crate::ExecutionCtx; use crate::array::ArrayView; use crate::array::OperationsVTable; use crate::arrays::Masked; -use crate::arrays::masked::MaskedArrayExt; +use crate::arrays::masked::MaskedArraySlotsExt; use crate::scalar::Scalar; impl OperationsVTable for Masked { From f382ccbe4eeb0d5101aed98633e838584494fcf9 Mon Sep 17 00:00:00 2001 From: Joe Isaacs Date: Tue, 28 Apr 2026 14:05:15 +0100 Subject: [PATCH 4/5] fix Signed-off-by: Joe Isaacs --- vortex-array/src/arrays/masked/execute.rs | 19 ++++++++----------- vortex-array/src/scalar_fn/fns/mask/mod.rs | 1 - 2 files changed, 8 insertions(+), 12 deletions(-) diff --git a/vortex-array/src/arrays/masked/execute.rs b/vortex-array/src/arrays/masked/execute.rs index 8886a56a017..f825e2dc451 100644 --- a/vortex-array/src/arrays/masked/execute.rs +++ b/vortex-array/src/arrays/masked/execute.rs @@ -80,17 +80,14 @@ fn mask_validity_decimal(array: DecimalArray, validity: Validity) -> VortexResul let values_type = array.values_type(); let new_validity = Validity::and(array.validity()?, validity)?; // SAFETY: We're only changing validity, not the data structure - Ok(match_each_decimal_value_type!(values_type, |T| { - let buffer = array.buffer::(); - unsafe { - DecimalArray::new_unchecked_handle( - array.buffer_handle().clone(), - array.values_type(), - array.decimal_dtype(), - new_validity, - ) - } - })) + Ok(unsafe { + DecimalArray::new_unchecked_handle( + array.buffer_handle().clone(), + array.values_type(), + array.decimal_dtype(), + new_validity, + ) + }) } /// Mask validity for VarBinViewArray. diff --git a/vortex-array/src/scalar_fn/fns/mask/mod.rs b/vortex-array/src/scalar_fn/fns/mask/mod.rs index e70b032390f..7e45d2e40ee 100644 --- a/vortex-array/src/scalar_fn/fns/mask/mod.rs +++ b/vortex-array/src/scalar_fn/fns/mask/mod.rs @@ -16,7 +16,6 @@ use crate::ExecutionCtx; use crate::IntoArray; use crate::arrays::Constant; use crate::arrays::ConstantArray; -use crate::arrays::bool::BoolArrayExt; use crate::arrays::masked::mask_validity_canonical; use crate::builtins::ArrayBuiltins; use crate::child_to_validity; From f9f6b221fbc5a748e20fc93426731554e55a9a38 Mon Sep 17 00:00:00 2001 From: Joe Isaacs Date: Tue, 28 Apr 2026 14:47:01 +0100 Subject: [PATCH 5/5] fix Signed-off-by: Joe Isaacs --- vortex-array/public-api.lock | 42 +++++++++++++++++++---- vortex-array/src/arrays/masked/execute.rs | 2 -- 2 files changed, 35 insertions(+), 9 deletions(-) diff --git a/vortex-array/public-api.lock b/vortex-array/public-api.lock index 8ee3c97f17b..b8304a18ef5 100644 --- a/vortex-array/public-api.lock +++ b/vortex-array/public-api.lock @@ -3164,23 +3164,51 @@ impl vortex_array::ArrayHash for vortex_array::arrays::masked::MaskedData pub fn vortex_array::arrays::masked::MaskedData::array_hash(&self, _state: &mut H, _precision: vortex_array::Precision) -pub trait vortex_array::arrays::masked::MaskedArrayExt: vortex_array::TypedArrayRef +pub struct vortex_array::arrays::masked::MaskedSlots -pub fn vortex_array::arrays::masked::MaskedArrayExt::child(&self) -> &vortex_array::ArrayRef +pub vortex_array::arrays::masked::MaskedSlots::child: vortex_array::ArrayRef -pub fn vortex_array::arrays::masked::MaskedArrayExt::masked_validity(&self) -> vortex_array::validity::Validity +pub vortex_array::arrays::masked::MaskedSlots::validity: core::option::Option + +impl vortex_array::arrays::masked::MaskedSlots + +pub const vortex_array::arrays::masked::MaskedSlots::CHILD: usize + +pub const vortex_array::arrays::masked::MaskedSlots::COUNT: usize + +pub const vortex_array::arrays::masked::MaskedSlots::NAMES: [&'static str; 2] -pub fn vortex_array::arrays::masked::MaskedArrayExt::validity_child(&self) -> core::option::Option<&vortex_array::ArrayRef> +pub const vortex_array::arrays::masked::MaskedSlots::VALIDITY: usize + +pub fn vortex_array::arrays::masked::MaskedSlots::from_slots(slots: alloc::vec::Vec>) -> Self + +pub fn vortex_array::arrays::masked::MaskedSlots::into_slots(self) -> alloc::vec::Vec> + +pub trait vortex_array::arrays::masked::MaskedArrayExt: vortex_array::TypedArrayRef + vortex_array::arrays::masked::MaskedArraySlotsExt + +pub fn vortex_array::arrays::masked::MaskedArrayExt::masked_validity(&self) -> vortex_array::validity::Validity impl> vortex_array::arrays::masked::MaskedArrayExt for T +pub fn T::masked_validity(&self) -> vortex_array::validity::Validity + +pub trait vortex_array::arrays::masked::MaskedArraySlotsExt: vortex_array::TypedArrayRef + +pub fn vortex_array::arrays::masked::MaskedArraySlotsExt::child(&self) -> &vortex_array::ArrayRef + +pub fn vortex_array::arrays::masked::MaskedArraySlotsExt::slots_view(&self) -> vortex_array::arrays::masked::array::MaskedSlotsView<'_> + +pub fn vortex_array::arrays::masked::MaskedArraySlotsExt::validity(&self) -> core::option::Option<&vortex_array::ArrayRef> + +impl> vortex_array::arrays::masked::MaskedArraySlotsExt for T + pub fn T::child(&self) -> &vortex_array::ArrayRef -pub fn T::masked_validity(&self) -> vortex_array::validity::Validity +pub fn T::slots_view(&self) -> vortex_array::arrays::masked::array::MaskedSlotsView<'_> -pub fn T::validity_child(&self) -> core::option::Option<&vortex_array::ArrayRef> +pub fn T::validity(&self) -> core::option::Option<&vortex_array::ArrayRef> -pub fn vortex_array::arrays::masked::mask_validity_canonical(canonical: vortex_array::Canonical, validity_mask: &vortex_mask::Mask, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult +pub fn vortex_array::arrays::masked::mask_validity_canonical(canonical: vortex_array::Canonical, validity: vortex_array::validity::Validity, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult pub type vortex_array::arrays::masked::MaskedArray = vortex_array::Array diff --git a/vortex-array/src/arrays/masked/execute.rs b/vortex-array/src/arrays/masked/execute.rs index f825e2dc451..354b246405c 100644 --- a/vortex-array/src/arrays/masked/execute.rs +++ b/vortex-array/src/arrays/masked/execute.rs @@ -26,7 +26,6 @@ use crate::arrays::listview::ListViewArrayExt; use crate::arrays::struct_::StructArrayExt; use crate::arrays::variant::VariantArrayExt; use crate::executor::ExecutionCtx; -use crate::match_each_decimal_value_type; use crate::validity::Validity; /// TODO: replace usage of compute fn. @@ -77,7 +76,6 @@ fn mask_validity_primitive( } fn mask_validity_decimal(array: DecimalArray, validity: Validity) -> VortexResult { - let values_type = array.values_type(); let new_validity = Validity::and(array.validity()?, validity)?; // SAFETY: We're only changing validity, not the data structure Ok(unsafe {