vortex_array/arrays/patched/vtable/
slice.rs1use std::ops::Range;
5
6use vortex_error::VortexResult;
7
8use crate::ArrayRef;
9use crate::IntoArray;
10use crate::array::ArrayView;
11use crate::arrays::Patched;
12use crate::arrays::patched::PatchedArrayExt;
13use crate::arrays::patched::PatchedArraySlotsExt;
14use crate::arrays::patched::PatchedSlots;
15use crate::arrays::slice::SliceReduce;
16
17impl SliceReduce for Patched {
18 fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
19 let new_offset = (range.start + array.offset()) % 1024;
22 let chunk_start = (range.start + array.offset()) / 1024;
23 let chunk_stop = (range.end + array.offset()).div_ceil(1024);
24 let sliced_lane_offsets = array
25 .lane_offsets()
26 .slice((chunk_start * array.n_lanes())..(chunk_stop * array.n_lanes()) + 1)?;
27
28 let inner = array.inner().slice(range.start..range.end)?;
32 let len = inner.len();
33
34 let slots = PatchedSlots {
35 inner,
36 lane_offsets: sliced_lane_offsets,
37 patch_indices: array.patch_indices().clone(),
38 patch_values: array.patch_values().clone(),
39 }
40 .into_slots();
41
42 Ok(Some(
43 unsafe {
44 Patched::new_unchecked(
45 array.dtype().clone(),
46 len,
47 slots,
48 array.n_lanes(),
49 new_offset,
50 )
51 }
52 .into_array(),
53 ))
54 }
55}
56
57#[cfg(test)]
58mod tests {
59 use std::ops::Range;
60 use std::sync::LazyLock;
61
62 use rstest::rstest;
63 use vortex_buffer::Buffer;
64 use vortex_buffer::BufferMut;
65 use vortex_buffer::buffer;
66 use vortex_error::VortexResult;
67 use vortex_session::VortexSession;
68
69 use crate::Canonical;
70 use crate::IntoArray;
71 use crate::VortexSessionExecute;
72 use crate::arrays::Patched;
73 use crate::arrays::PrimitiveArray;
74 use crate::assert_arrays_eq;
75 use crate::dtype::NativePType;
76 use crate::patches::Patches;
77
78 static SESSION: LazyLock<VortexSession> = LazyLock::new(VortexSession::empty);
79
80 #[test]
81 fn test_reduce() -> VortexResult<()> {
82 let mut ctx = SESSION.create_execution_ctx();
83 let values = buffer![0u16; 512].into_array();
84 let patch_indices = buffer![1u32, 8, 30].into_array();
85 let patch_values = buffer![u16::MAX; 3].into_array();
86 let patches = Patches::new(512, 0, patch_indices, patch_values, None, &mut ctx)?;
87
88 let mut ctx = SESSION.create_execution_ctx();
89
90 let patched_array = Patched::from_array_and_patches(values, &patches, &mut ctx)?;
91
92 let sliced = patched_array.into_array().slice(1..10)?;
93
94 insta::assert_snapshot!(
95 sliced.display_tree_encodings_only(),
96 @r#"
97 root: vortex.patched(u16, len=9)
98 inner: vortex.primitive(u16, len=9)
99 lane_offsets: vortex.primitive(u32, len=33)
100 patch_indices: vortex.primitive(u16, len=3)
101 patch_values: vortex.primitive(u16, len=3)
102 "#);
103
104 let executed = sliced.execute::<Canonical>(&mut ctx)?.into_primitive();
105
106 assert_eq!(
107 &[u16::MAX, 0, 0, 0, 0, 0, 0, u16::MAX, 0],
108 executed.as_slice::<u16>()
109 );
110
111 Ok(())
112 }
113
114 #[rstest]
115 #[case::trivial(buffer![1u64; 2], buffer![1u32], buffer![u64::MAX], 1..2)]
116 #[case::one_chunk(buffer![0u64; 1024], buffer![1u32, 8, 30], buffer![u64::MAX; 3], 1..10)]
117 #[case::multichunk(buffer![1u64; 10_000], buffer![0u32, 1, 2, 3, 4, 16, 17, 18, 19, 1024, 2048, 2049], buffer![u64::MAX; 12], 1024..5000)]
118 fn test_cases<T: NativePType>(
119 #[case] inner: Buffer<T>,
120 #[case] patch_indices: Buffer<u32>,
121 #[case] patch_values: Buffer<T>,
122 #[case] range: Range<usize>,
123 ) {
124 let mut expected = inner.to_vec();
125 for (&index, &value) in patch_indices.iter().zip(patch_values.iter()) {
126 expected[index as usize] = value;
127 }
128 let expected = PrimitiveArray::from_iter(expected[range.clone()].iter().copied());
129
130 let patches = Patches::new(
132 inner.len(),
133 0,
134 patch_indices.into_array(),
135 patch_values.into_array(),
136 None,
137 &mut SESSION.create_execution_ctx(),
138 )
139 .unwrap();
140
141 let mut ctx = SESSION.create_execution_ctx();
142
143 let patched_array = Patched::from_array_and_patches(inner.into_array(), &patches, &mut ctx)
144 .unwrap()
145 .into_array();
146
147 let slice_first = patched_array.slice(range).unwrap();
148
149 assert_arrays_eq!(slice_first, &expected, &mut ctx);
150 }
151
152 #[test]
153 fn test_stacked_slices() {
154 let mut ctx = SESSION.create_execution_ctx();
155 let values = PrimitiveArray::from_iter(0u64..10_000).into_array();
156
157 let patched_indices = buffer![1u32, 2, 1024, 2048, 3072, 3088].into_array();
158 let patched_values = buffer![0u64, 1, 2, 3, 4, 5].into_array();
159
160 let patches =
161 Patches::new(10_000, 0, patched_indices, patched_values, None, &mut ctx).unwrap();
162
163 let patched_array = Patched::from_array_and_patches(values, &patches, &mut ctx)
164 .unwrap()
165 .into_array();
166
167 let sliced = patched_array
168 .slice(1024..5000)
169 .unwrap()
170 .slice(1..2065)
171 .unwrap();
172
173 let mut expected = BufferMut::from_iter(1025u64..=3088);
174 expected[1023] = 3;
175 expected[2047] = 4;
176 expected[2063] = 5;
177
178 let expected = expected.into_array();
179
180 assert_arrays_eq!(sliced, expected, &mut ctx);
181 }
182}