Replace FilterMask with vortex-mask (#2056)

Author: gatesn

Cargo.lock

@@ -158,6 +158,7 @@ vortex-fsst = { version = "0.22.1", path = "./encodings/fsst" }
 vortex-io = { version = "0.22.1", path = "./vortex-io" }
 vortex-ipc = { version = "0.22.1", path = "./vortex-ipc" }
 vortex-layout = { version = "0.22.1", path = "./vortex-layout" }
+vortex-mask = { version = "0.22.1", path = "./vortex-mask" }
 vortex-proto = { version = "0.22.1", path = "./vortex-proto" }
 vortex-runend = { version = "0.22.1", path = "./encodings/runend" }
 vortex-scalar = { version = "0.22.1", path = "./vortex-scalar", default-features = false }

Cargo.toml

@@ -25,6 +25,7 @@ vortex-buffer = { workspace = true }
 vortex-dtype = { workspace = true }
 vortex-error = { workspace = true }
 vortex-fastlanes = { workspace = true }
+vortex-mask = { workspace = true }
 vortex-scalar = { workspace = true }
 
 [dev-dependencies]

encodings/alp/Cargo.toml

@@ -1,10 +1,10 @@
 use vortex_array::compute::{
-    filter, scalar_at, slice, take, ComputeVTable, FilterFn, FilterMask, ScalarAtFn, SliceFn,
-    TakeFn,
+    filter, scalar_at, slice, take, ComputeVTable, FilterFn, ScalarAtFn, SliceFn, TakeFn,
 };
 use vortex_array::variants::PrimitiveArrayTrait;
 use vortex_array::{ArrayDType, ArrayData, IntoArrayData};
 use vortex_error::VortexResult;
+use vortex_mask::Mask;
 use vortex_scalar::Scalar;
 
 use crate::{match_each_alp_float_ptype, ALPArray, ALPEncoding, ALPFloat};
@@ -79,7 +79,7 @@ impl SliceFn<ALPArray> for ALPEncoding {
 }
 
 impl FilterFn<ALPArray> for ALPEncoding {
-    fn filter(&self, array: &ALPArray, mask: &FilterMask) -> VortexResult<ArrayData> {
+    fn filter(&self, array: &ALPArray, mask: &Mask) -> VortexResult<ArrayData> {
         let patches = array
             .patches()
             .map(|p| p.filter(mask))

encodings/alp/src/alp/compute/mod.rs

@@ -1,11 +1,12 @@
-use vortex_array::compute::{filter, FilterFn, FilterMask};
+use vortex_array::compute::{filter, FilterFn};
 use vortex_array::{ArrayDType, ArrayData, IntoArrayData};
 use vortex_error::VortexResult;
+use vortex_mask::Mask;
 
 use crate::{ALPRDArray, ALPRDEncoding};
 
 impl FilterFn<ALPRDArray> for ALPRDEncoding {
-    fn filter(&self, array: &ALPRDArray, mask: &FilterMask) -> VortexResult<ArrayData> {
+    fn filter(&self, array: &ALPRDArray, mask: &Mask) -> VortexResult<ArrayData> {
         let left_parts_exceptions = array
             .left_parts_patches()
             .map(|patches| patches.filter(mask))
@@ -28,10 +29,11 @@ impl FilterFn<ALPRDArray> for ALPRDEncoding {
 mod test {
     use rstest::rstest;
     use vortex_array::array::PrimitiveArray;
-    use vortex_array::compute::{filter, FilterMask};
+    use vortex_array::compute::filter;
     use vortex_array::validity::Validity;
     use vortex_array::IntoArrayVariant;
     use vortex_buffer::buffer;
+    use vortex_mask::Mask;
 
     use crate::{ALPRDFloat, RDEncoder};
 
@@ -46,13 +48,10 @@ mod test {
         assert!(encoded.left_parts_patches().is_some());
 
         // The first two values need no patching
-        let filtered = filter(
-            encoded.as_ref(),
-            &FilterMask::from_iter([true, false, true]),
-        )
-        .unwrap()
-        .into_primitive()
-        .unwrap();
+        let filtered = filter(encoded.as_ref(), &Mask::from_iter([true, false, true]))
+            .unwrap()
+            .into_primitive()
+            .unwrap();
         assert_eq!(filtered.as_slice::<T>(), &[a, outlier]);
     }
 }

encodings/alp/src/alp_rd/compute/filter.rs

@@ -23,6 +23,7 @@ vortex-buffer = { workspace = true }
 vortex-datetime-dtype = { workspace = true }
 vortex-dtype = { workspace = true }
 vortex-error = { workspace = true }
+vortex-mask = { workspace = true }
 vortex-scalar = { workspace = true }
 
 [dev-dependencies]

encodings/datetime-parts/Cargo.toml

@@ -1,11 +1,12 @@
-use vortex_array::compute::{filter, FilterFn, FilterMask};
+use vortex_array::compute::{filter, FilterFn};
 use vortex_array::{ArrayDType, ArrayData, IntoArrayData};
 use vortex_error::VortexResult;
+use vortex_mask::Mask;
 
 use crate::{DateTimePartsArray, DateTimePartsEncoding};
 
 impl FilterFn<DateTimePartsArray> for DateTimePartsEncoding {
-    fn filter(&self, array: &DateTimePartsArray, mask: &FilterMask) -> VortexResult<ArrayData> {
+    fn filter(&self, array: &DateTimePartsArray, mask: &Mask) -> VortexResult<ArrayData> {
         Ok(DateTimePartsArray::try_new(
             array.dtype().clone(),
             filter(array.days().as_ref(), mask)?,

encodings/datetime-parts/src/compute/filter.rs

@@ -21,6 +21,7 @@ vortex-array = { workspace = true }
 vortex-buffer = { workspace = true }
 vortex-dtype = { workspace = true }
 vortex-error = { workspace = true }
+vortex-mask = { workspace = true }
 vortex-scalar = { workspace = true }
 
 [lints]

encodings/dict/Cargo.toml

@@ -3,11 +3,12 @@ mod compare;
 mod like;
 
 use vortex_array::compute::{
-    filter, scalar_at, slice, take, BinaryNumericFn, CompareFn, ComputeVTable, FilterFn,
-    FilterMask, LikeFn, ScalarAtFn, SliceFn, TakeFn,
+    filter, scalar_at, slice, take, BinaryNumericFn, CompareFn, ComputeVTable, FilterFn, LikeFn,
+    ScalarAtFn, SliceFn, TakeFn,
 };
 use vortex_array::{ArrayData, IntoArrayData};
 use vortex_error::VortexResult;
+use vortex_mask::Mask;
 use vortex_scalar::Scalar;
 
 use crate::{DictArray, DictEncoding};
@@ -60,7 +61,7 @@ impl TakeFn<DictArray> for DictEncoding {
 }
 
 impl FilterFn<DictArray> for DictEncoding {
-    fn filter(&self, array: &DictArray, mask: &FilterMask) -> VortexResult<ArrayData> {
+    fn filter(&self, array: &DictArray, mask: &Mask) -> VortexResult<ArrayData> {
         let codes = filter(&array.codes(), mask)?;
         DictArray::try_new(codes, array.values()).map(|a| a.into_array())
     }

encodings/dict/src/compute/mod.rs

@@ -28,6 +28,7 @@ vortex-array = { workspace = true }
 vortex-buffer = { workspace = true }
 vortex-dtype = { workspace = true }
 vortex-error = { workspace = true }
+vortex-mask = { workspace = true }
 vortex-scalar = { workspace = true }
 
 [dev-dependencies]