Removed unused validity_mask vtable function

encodings/runend/src/array.rs

@@ -15,7 +15,6 @@ use vortex_array::IntoArray;
 use vortex_array::Precision;
 use vortex_array::ProstMetadata;
 use vortex_array::SerializeMetadata;
-use vortex_array::ToCanonical;
 use vortex_array::arrays::PrimitiveVTable;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::search_sorted::SearchSorted;
@@ -38,7 +37,6 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
 use vortex_error::vortex_panic;
-use vortex_mask::Mask;
 use vortex_scalar::PValue;
 
 use crate::compress::runend_decode_bools;
@@ -455,27 +453,6 @@ impl ValidityVTable<RunEndVTable> for RunEndVTable {
             }),
         })
     }
-
-    fn validity_mask(array: &RunEndArray) -> VortexResult<Mask> {
-        Ok(match array.values().validity_mask()? {
-            Mask::AllTrue(_) => Mask::AllTrue(array.len()),
-            Mask::AllFalse(_) => Mask::AllFalse(array.len()),
-            Mask::Values(values) => {
-                // SAFETY: we preserve ends from an existing validated RunEndArray.
-                //  Validity is checked on construction to have the correct len.
-                let ree_validity = unsafe {
-                    RunEndArray::new_unchecked(
-                        array.ends().clone(),
-                        values.into_array(),
-                        array.offset(),
-                        array.len(),
-                    )
-                    .into_array()
-                };
-                Mask::from_buffer(ree_validity.to_bool().bit_buffer().clone())
-            }
-        })
-    }
 }
 
 pub(super) fn run_end_canonicalize(

encodings/sequence/src/array.rs

@@ -400,10 +400,6 @@ impl ValidityVTable<SequenceVTable> for SequenceVTable {
     fn validity(_array: &SequenceArray) -> VortexResult<Validity> {
         Ok(Validity::AllValid)
     }
-
-    fn validity_mask(array: &SequenceArray) -> VortexResult<Mask> {
-        Ok(Mask::AllTrue(array.len()))
-    }
 }
 
 impl VisitorVTable<SequenceVTable> for SequenceVTable {

encodings/sparse/src/lib.rs

@@ -5,8 +5,6 @@ use std::fmt::Debug;
 use std::hash::Hash;
 use std::ops::Range;
 
-use itertools::Itertools as _;
-use num_traits::AsPrimitive;
 use prost::Message as _;
 use vortex_array::Array;
 use vortex_array::ArrayBufferVisitor;
@@ -40,13 +38,10 @@ use vortex_array::vtable::NotSupported;
 use vortex_array::vtable::VTable;
 use vortex_array::vtable::ValidityVTable;
 use vortex_array::vtable::VisitorVTable;
-use vortex_buffer::BitBufferMut;
 use vortex_buffer::Buffer;
 use vortex_buffer::ByteBufferMut;
 use vortex_dtype::DType;
-use vortex_dtype::NativePType;
 use vortex_dtype::Nullability;
-use vortex_dtype::match_each_integer_ptype;
 use vortex_error::VortexExpect as _;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
@@ -429,62 +424,6 @@ impl ValidityVTable<SparseVTable> for SparseVTable {
                 .into_array(),
         ))
     }
-
-    fn validity_mask(array: &SparseArray) -> VortexResult<Mask> {
-        let fill_is_valid = array.fill_scalar().is_valid();
-        let values_validity = array.patches().values().validity_mask()?;
-        let len = array.len();
-
-        if matches!(values_validity, Mask::AllTrue(_)) && fill_is_valid {
-            return Ok(Mask::AllTrue(len));
-        }
-        if matches!(values_validity, Mask::AllFalse(_)) && !fill_is_valid {
-            return Ok(Mask::AllFalse(len));
-        }
-
-        let mut is_valid_buffer = if fill_is_valid {
-            BitBufferMut::new_set(len)
-        } else {
-            BitBufferMut::new_unset(len)
-        };
-
-        let indices = array.patches().indices().to_primitive();
-        let index_offset = array.patches().offset();
-
-        match_each_integer_ptype!(indices.ptype(), |I| {
-            let indices = indices.as_slice::<I>();
-            patch_validity(&mut is_valid_buffer, indices, index_offset, values_validity);
-        });
-
-        Ok(Mask::from_buffer(is_valid_buffer.freeze()))
-    }
-}
-
-fn patch_validity<I: NativePType + AsPrimitive<usize>>(
-    is_valid_buffer: &mut BitBufferMut,
-    indices: &[I],
-    index_offset: usize,
-    values_validity: Mask,
-) {
-    let indices = indices.iter().map(|index| index.as_() - index_offset);
-    match values_validity {
-        Mask::AllTrue(_) => {
-            for index in indices {
-                is_valid_buffer.set(index);
-            }
-        }
-        Mask::AllFalse(_) => {
-            for index in indices {
-                is_valid_buffer.unset(index);
-            }
-        }
-        Mask::Values(mask_values) => {
-            let is_valid = mask_values.bit_buffer().iter();
-            for (index, is_valid) in indices.zip_eq(is_valid) {
-                is_valid_buffer.set_to(index, is_valid);
-            }
-        }
-    }
 }
 
 impl VisitorVTable<SparseVTable> for SparseVTable {

vortex-array/src/arrays/chunked/vtable/validity.rs

@@ -5,7 +5,6 @@ use itertools::Itertools;
 use vortex_dtype::DType;
 use vortex_dtype::Nullability;
 use vortex_error::VortexResult;
-use vortex_mask::Mask;
 
 use crate::Array;
 use crate::IntoArray;
@@ -52,8 +51,4 @@ impl ValidityVTable<ChunkedVTable> for ChunkedVTable {
             .into_array(),
         ))
     }
-
-    fn validity_mask(array: &ChunkedArray) -> VortexResult<Mask> {
-        array.chunks().iter().map(|a| a.validity_mask()).collect()
-    }
 }

vortex-array/src/arrays/constant/vtable/validity.rs

@@ -2,7 +2,6 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_error::VortexResult;
-use vortex_mask::Mask;
 
 use crate::arrays::ConstantArray;
 use crate::arrays::ConstantVTable;
@@ -17,11 +16,4 @@ impl ValidityVTable<ConstantVTable> for ConstantVTable {
             Validity::AllValid
         })
     }
-
-    fn validity_mask(array: &ConstantArray) -> VortexResult<Mask> {
-        Ok(match array.scalar().is_null() {
-            true => Mask::AllFalse(array.len),
-            false => Mask::AllTrue(array.len),
-        })
-    }
 }

vortex-array/src/arrays/dict/vtable/validity.rs

@@ -1,18 +1,13 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_buffer::BitBuffer;
 use vortex_dtype::Nullability;
-use vortex_dtype::match_each_integer_ptype;
 use vortex_error::VortexResult;
-use vortex_mask::AllOr;
-use vortex_mask::Mask;
 use vortex_scalar::Scalar;
 
 use super::DictVTable;
 use crate::Array;
 use crate::IntoArray;
-use crate::ToCanonical;
 use crate::arrays::dict::DictArray;
 use crate::compute::fill_null;
 use crate::validity::Validity;
@@ -54,35 +49,4 @@ impl ValidityVTable<DictVTable> for DictVTable {
             },
         )
     }
-
-    fn validity_mask(array: &DictArray) -> VortexResult<Mask> {
-        let codes_validity = array.codes().validity_mask()?;
-        Ok(match codes_validity.bit_buffer() {
-            AllOr::All => {
-                let primitive_codes = array.codes().to_primitive();
-                let values_mask = array.values().validity_mask()?;
-                let is_valid_buffer = match_each_integer_ptype!(primitive_codes.ptype(), |P| {
-                    let codes_slice = primitive_codes.as_slice::<P>();
-                    BitBuffer::collect_bool(array.len(), |idx| {
-                        #[allow(clippy::cast_possible_truncation)]
-                        values_mask.value(codes_slice[idx] as usize)
-                    })
-                });
-                Mask::from_buffer(is_valid_buffer)
-            }
-            AllOr::None => Mask::AllFalse(array.len()),
-            AllOr::Some(validity_buff) => {
-                let primitive_codes = array.codes().to_primitive();
-                let values_mask = array.values().validity_mask()?;
-                let is_valid_buffer = match_each_integer_ptype!(primitive_codes.ptype(), |P| {
-                    let codes_slice = primitive_codes.as_slice::<P>();
-                    #[allow(clippy::cast_possible_truncation)]
-                    BitBuffer::collect_bool(array.len(), |idx| {
-                        validity_buff.value(idx) && values_mask.value(codes_slice[idx] as usize)
-                    })
-                });
-                Mask::from_buffer(is_valid_buffer)
-            }
-        })
-    }
 }

vortex-array/src/arrays/filter/vtable.rs

@@ -5,7 +5,6 @@ use std::fmt::Debug;
 use std::fmt::Formatter;
 use std::hash::Hasher;
 
-use vortex_compute::filter::Filter;
 use vortex_dtype::DType;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
@@ -200,10 +199,6 @@ impl ValidityVTable<FilterVTable> for FilterVTable {
     fn validity(array: &FilterArray) -> VortexResult<Validity> {
         array.child.validity()?.filter(&array.mask)
     }
-
-    fn validity_mask(array: &FilterArray) -> VortexResult<Mask> {
-        Ok(Filter::filter(&array.child.validity_mask()?, &array.mask))
-    }
 }
 
 impl VisitorVTable<FilterVTable> for FilterVTable {

vortex-array/src/arrays/masked/array.rs

@@ -4,7 +4,6 @@
 use vortex_dtype::DType;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
-use vortex_mask::Mask;
 
 use crate::ArrayRef;
 use crate::stats::ArrayStats;
@@ -49,9 +48,4 @@ impl MaskedArray {
     pub fn child(&self) -> &ArrayRef {
         &self.child
     }
-
-    /// Get the validity mask for this array.
-    pub fn validity_mask(&self) -> Mask {
-        self.validity.to_mask(self.len())
-    }
 }

vortex-array/src/arrays/masked/tests.rs

@@ -97,5 +97,5 @@ fn test_masked_child_preserves_length(#[case] validity: Validity) {
     let array = MaskedArray::try_new(child, validity.clone()).unwrap();
 
     assert_eq!(array.len(), len);
-    assert_eq!(array.validity_mask(), validity.to_mask(len));
+    assert_eq!(array.validity_mask().unwrap(), validity.to_mask(len));
 }

vortex-array/src/arrays/masked/vtable/mod.rs

@@ -125,7 +125,7 @@ impl VTable for MaskedVTable {
     }
 
     fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<Canonical> {
-        let validity_mask = array.validity_mask();
+        let validity_mask = array.validity_mask()?;
 
         // Fast path: all masked means result is all nulls.
         if validity_mask.all_false() {

vortex-array/src/arrays/null/mod.rs

@@ -7,7 +7,6 @@ use std::ops::Range;
 use vortex_dtype::DType;
 use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
-use vortex_mask::Mask;
 use vortex_scalar::Scalar;
 
 use crate::ArrayBufferVisitor;
@@ -175,8 +174,4 @@ impl ValidityVTable<NullVTable> for NullVTable {
     fn validity(_array: &NullArray) -> VortexResult<Validity> {
         Ok(Validity::AllInvalid)
     }
-
-    fn validity_mask(array: &NullArray) -> VortexResult<Mask> {
-        Ok(Mask::AllFalse(array.len))
-    }
 }

vortex-array/src/arrays/scalar_fn/vtable/validity.rs

@@ -4,7 +4,6 @@
 use std::sync::Arc;
 
 use vortex_error::VortexResult;
-use vortex_mask::Mask;
 
 use crate::ArrayRef;
 use crate::IntoArray;
@@ -14,7 +13,6 @@ use crate::arrays::scalar_fn::array::ScalarFnArray;
 use crate::arrays::scalar_fn::vtable::ArrayExpr;
 use crate::arrays::scalar_fn::vtable::FakeEq;
 use crate::arrays::scalar_fn::vtable::ScalarFnVTable;
-use crate::executor::CanonicalOutput;
 use crate::expr::ExecutionArgs;
 use crate::expr::Expression;
 use crate::expr::Literal;
@@ -76,13 +74,4 @@ impl ValidityVTable<ScalarFnVTable> for ScalarFnVTable {
         // Execute the validity expression. All leaves are ArrayExpr nodes.
         Ok(Validity::Array(execute_expr(&validity_expr, array.len())?))
     }
-
-    fn validity_mask(array: &ScalarFnArray) -> VortexResult<Mask> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
-        let output = array.to_array().execute::<CanonicalOutput>(&mut ctx)?;
-        Ok(match output {
-            CanonicalOutput::Constant(c) => Mask::new(array.len, c.scalar().is_valid()),
-            CanonicalOutput::Array(a) => a.into_array().validity()?.to_mask(array.len()),
-        })
-    }
 }

vortex-array/src/arrays/slice/vtable.rs

@@ -12,7 +12,6 @@ use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
-use vortex_mask::Mask;
 use vortex_scalar::Scalar;
 
 use crate::Array;
@@ -166,10 +165,6 @@ impl ValidityVTable<SliceVTable> for SliceVTable {
     fn validity(array: &SliceArray) -> VortexResult<Validity> {
         Ok(array.child.validity()?.slice(array.range.clone()))
     }
-
-    fn validity_mask(array: &SliceArray) -> VortexResult<Mask> {
-        Ok(array.child.validity_mask()?.slice(array.range.clone()))
-    }
 }
 
 impl VisitorVTable<SliceVTable> for SliceVTable {

vortex-array/src/arrow/array.rs

@@ -12,7 +12,6 @@ use vortex_dtype::arrow::FromArrowType;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
-use vortex_mask::Mask;
 use vortex_scalar::Scalar;
 
 use crate::ArrayBufferVisitor;
@@ -171,14 +170,6 @@ impl ValidityVTable<ArrowVTable> for ArrowVTable {
             },
         })
     }
-
-    fn validity_mask(array: &ArrowArray) -> VortexResult<Mask> {
-        Ok(array
-            .inner
-            .logical_nulls()
-            .map(|null_buffer| Mask::from_buffer(null_buffer.inner().clone().into()))
-            .unwrap_or_else(|| Mask::new_true(array.inner.len())))
-    }
 }
 
 impl VisitorVTable<ArrowVTable> for ArrowVTable {