vortex_array/arrays/bool/
mod.rs

1mod array;
2pub mod compute;
3mod patch;
4mod serde;
5
6pub use array::*;
7// Re-export the BooleanBuffer type on our API surface.
8pub use arrow_buffer::{BooleanBuffer, BooleanBufferBuilder};
9
10#[cfg(test)]
11mod tests {
12    use arrow_buffer::{BooleanBuffer, BooleanBufferBuilder};
13    use vortex_buffer::buffer;
14
15    use crate::ToCanonical;
16    use crate::array::Array;
17    use crate::arrays::{BoolArray, PrimitiveArray};
18    use crate::compute::conformance::mask::test_mask;
19    use crate::compute::{scalar_at, slice};
20    use crate::patches::Patches;
21    use crate::validity::Validity;
22
23    #[test]
24    fn bool_array() {
25        let arr = BoolArray::from_iter([true, false, true]);
26        let scalar = bool::try_from(&scalar_at(&arr, 0).unwrap()).unwrap();
27        assert!(scalar);
28    }
29
30    #[test]
31    fn test_all_some_iter() {
32        let arr = BoolArray::from_iter([Some(true), Some(false)]);
33
34        assert!(matches!(arr.validity(), Validity::AllValid));
35
36        let scalar = bool::try_from(&scalar_at(&arr, 0).unwrap()).unwrap();
37        assert!(scalar);
38        let scalar = bool::try_from(&scalar_at(&arr, 1).unwrap()).unwrap();
39        assert!(!scalar);
40    }
41
42    #[test]
43    fn test_bool_from_iter() {
44        let arr = BoolArray::from_iter([Some(true), Some(true), None, Some(false), None]);
45
46        let scalar = bool::try_from(&scalar_at(&arr, 0).unwrap()).unwrap();
47        assert!(scalar);
48
49        let scalar = bool::try_from(&scalar_at(&arr, 1).unwrap()).unwrap();
50        assert!(scalar);
51
52        let scalar = scalar_at(&arr, 2).unwrap();
53        assert!(scalar.is_null());
54
55        let scalar = bool::try_from(&scalar_at(&arr, 3).unwrap()).unwrap();
56        assert!(!scalar);
57
58        let scalar = scalar_at(&arr, 4).unwrap();
59        assert!(scalar.is_null());
60    }
61
62    #[test]
63    fn patch_sliced_bools() {
64        let arr = {
65            let mut builder = BooleanBufferBuilder::new(12);
66            builder.append(false);
67            builder.append_n(11, true);
68            BoolArray::from(builder.finish())
69        };
70        let sliced = slice(&arr, 4, 12).unwrap();
71        let sliced_len = sliced.len();
72        let (values, offset) = sliced.to_bool().unwrap().into_boolean_builder();
73        assert_eq!(offset, 4);
74        assert_eq!(values.as_slice(), &[254, 15]);
75
76        // patch the underlying array
77        let patches = Patches::new(
78            arr.len(),
79            0,
80            PrimitiveArray::new(buffer![4u32], Validity::AllValid).into_array(),
81            BoolArray::from(BooleanBuffer::new_unset(1)).into_array(),
82        );
83        let arr = arr.patch(&patches).unwrap();
84        let arr_len = arr.len();
85        let (values, offset) = arr.to_bool().unwrap().into_boolean_builder();
86        assert_eq!(offset, 0);
87        assert_eq!(values.len(), arr_len + offset);
88        assert_eq!(values.as_slice(), &[238, 15]);
89
90        // the slice should be unchanged
91        let (values, offset) = sliced.to_bool().unwrap().into_boolean_builder();
92        assert_eq!(offset, 4);
93        assert_eq!(values.len(), sliced_len + offset);
94        assert_eq!(values.as_slice(), &[254, 15]); // unchanged
95    }
96
97    #[test]
98    fn slice_array_in_middle() {
99        let arr = BoolArray::from(BooleanBuffer::new_set(16));
100        let sliced = slice(&arr, 4, 12).unwrap();
101        let sliced_len = sliced.len();
102        let (values, offset) = sliced.to_bool().unwrap().into_boolean_builder();
103        assert_eq!(offset, 4);
104        assert_eq!(values.len(), sliced_len + offset);
105        assert_eq!(values.as_slice(), &[255, 15]);
106    }
107
108    #[test]
109    #[should_panic]
110    fn patch_bools_owned() {
111        let buffer = buffer![255u8; 2];
112        let buf = BooleanBuffer::new(buffer.into_arrow_buffer(), 0, 15);
113        let arr = BoolArray::new(buf, Validity::NonNullable);
114        let buf_ptr = arr.boolean_buffer().sliced().as_ptr();
115
116        let patches = Patches::new(
117            arr.len(),
118            0,
119            PrimitiveArray::new(buffer![0u32], Validity::AllValid).into_array(),
120            BoolArray::from(BooleanBuffer::new_unset(1)).into_array(),
121        );
122        let arr = arr.patch(&patches).unwrap();
123        assert_eq!(arr.boolean_buffer().sliced().as_ptr(), buf_ptr);
124
125        let (values, _byte_bit_offset) = arr.to_bool().unwrap().into_boolean_builder();
126        assert_eq!(values.as_slice(), &[254, 127]);
127    }
128
129    #[test]
130    fn test_mask_primitive_array() {
131        test_mask(&BoolArray::from_iter([true, false, true, true, false]));
132    }
133}
vortex_array/arrays/bool/mod.rs

vortex_array/arrays/bool/
mod.rs
