Skip to main content

vortex_array/arrays/bool/compute/
mask.rs

1// SPDX-License-Identifier: Apache-2.0
2// SPDX-FileCopyrightText: Copyright the Vortex contributors
3
4use vortex_error::VortexResult;
5
6use crate::ArrayRef;
7use crate::IntoArray;
8use crate::array::ArrayView;
9use crate::arrays::Bool;
10use crate::arrays::BoolArray;
11use crate::scalar_fn::fns::mask::MaskReduce;
12use crate::validity::Validity;
13
14impl MaskReduce for Bool {
15    const VALIDITY_IS_METADATA_ONLY: bool = true;
16
17    fn mask(array: ArrayView<'_, Bool>, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
18        Ok(Some(
19            BoolArray::try_new_from_handle(
20                array.bits.clone(),
21                array.meta.offset(),
22                array.len(),
23                array.validity()?.and(Validity::Array(mask.clone()))?,
24            )?
25            .into_array(),
26        ))
27    }
28}
29
30#[cfg(test)]
31mod tests {
32    use std::any::Any;
33    use std::ops::Range;
34    use std::sync::Arc;
35    use std::sync::LazyLock;
36
37    use futures::future::BoxFuture;
38    use rstest::rstest;
39    use vortex_buffer::Alignment;
40    use vortex_buffer::ByteBuffer;
41    use vortex_error::VortexResult;
42    use vortex_error::vortex_bail;
43    use vortex_session::VortexSession;
44
45    use crate::ArrayEq;
46    use crate::ArrayRef;
47    use crate::EqMode;
48    use crate::IntoArray;
49    use crate::VortexSessionExecute;
50    use crate::arrays::Bool;
51    use crate::arrays::BoolArray;
52    use crate::buffer::BufferHandle;
53    use crate::buffer::DeviceBuffer;
54    use crate::compute::conformance::mask::test_mask_conformance;
55    use crate::scalar_fn::fns::mask::MaskReduce;
56    use crate::validity::Validity;
57
58    static SESSION: LazyLock<VortexSession> = LazyLock::new(VortexSession::empty);
59
60    // Any access beyond buffer metadata would invalidate the metadata-only reduction.
61    #[derive(Debug, PartialEq, Eq, Hash)]
62    struct MetadataOnlyDeviceBuffer(usize);
63
64    impl DeviceBuffer for MetadataOnlyDeviceBuffer {
65        fn as_any(&self) -> &dyn Any {
66            self
67        }
68
69        fn len(&self) -> usize {
70            self.0
71        }
72
73        fn alignment(&self) -> Alignment {
74            Alignment::of::<u8>()
75        }
76
77        fn copy_to_host_sync(&self, _alignment: Alignment) -> VortexResult<ByteBuffer> {
78            vortex_bail!("mask reduction must not copy device values")
79        }
80
81        fn copy_to_host(
82            &self,
83            _alignment: Alignment,
84        ) -> VortexResult<BoxFuture<'static, VortexResult<ByteBuffer>>> {
85            vortex_bail!("mask reduction must not copy device values")
86        }
87
88        fn slice(&self, _range: Range<usize>) -> Arc<dyn DeviceBuffer> {
89            panic!("mask reduction must preserve the original buffer");
90        }
91
92        fn aligned(self: Arc<Self>, alignment: Alignment) -> VortexResult<Arc<dyn DeviceBuffer>> {
93            assert_eq!(self.alignment(), alignment);
94            Ok(self)
95        }
96    }
97
98    #[test]
99    fn mask_preserves_device_buffer_and_bit_offset() -> VortexResult<()> {
100        let handle = BufferHandle::new_device(Arc::new(MetadataOnlyDeviceBuffer(1)));
101        let input = BoolArray::try_new_from_handle(handle, 3, 5, Validity::AllValid)?;
102        let mask = BoolArray::from_iter([true, false, true, false, true]).into_array();
103        let masked = <Bool as MaskReduce>::mask(input.as_ref().as_::<Bool>(), &mask)?
104            .expect("Boolean masking must reduce");
105        let output = masked.as_::<Bool>();
106
107        assert!(output.bits.array_eq(&input.bits, EqMode::Ptr));
108        assert_eq!(output.meta.offset(), input.meta.offset());
109        assert_eq!(output.len(), input.len());
110        let Validity::Array(validity) = masked.validity()? else {
111            panic!("mask must remain array-backed");
112        };
113        assert!(ArrayRef::ptr_eq(&validity, &mask));
114
115        Ok(())
116    }
117
118    #[rstest]
119    #[case(BoolArray::from_iter([true, false, true, true, false]))]
120    #[case(BoolArray::from_iter([Some(true), None, Some(false), Some(true), None]))]
121    #[case(BoolArray::from_iter([true]))]
122    #[case(BoolArray::from_iter([false, false]))]
123    #[case(BoolArray::from_iter((0..100).map(|i| i % 2 == 0)))]
124    fn test_mask_bool_conformance(#[case] array: BoolArray) {
125        test_mask_conformance(&array.into_array(), &mut SESSION.create_execution_ctx());
126    }
127}