Remove operators

Signed-off-by: Nicholas Gates <[email protected]>

Author: gatesn

Cargo.lock

@@ -28,6 +28,7 @@ vortex-error = { workspace = true }
 vortex-fastlanes = { workspace = true }
 vortex-mask = { workspace = true }
 vortex-scalar = { workspace = true }
+vortex-session = { workspace = true }
 vortex-utils = { workspace = true }
 vortex-vector = { workspace = true }
 

encodings/alp/Cargo.toml

@@ -453,15 +453,19 @@ impl VisitorVTable<ALPVTable> for ALPVTable {
 #[cfg(test)]
 mod tests {
     use std::f64::consts::PI;
+    use std::sync::LazyLock;
 
     use rstest::rstest;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::vtable::ValidityHelper;
     use vortex_dtype::PTypeDowncast;
+    use vortex_session::VortexSession;
     use vortex_vector::VectorOps;
 
     use super::*;
 
+    static SESSION: LazyLock<VortexSession> = LazyLock::new(|| VortexSession::empty());
+
     #[rstest]
     #[case(0)]
     #[case(1)]
@@ -476,7 +480,10 @@ mod tests {
         let values = PrimitiveArray::from_iter((0..size).map(|i| i as f32));
         let encoded = alp_encode(&values, None).unwrap();
 
-        let result_vector = encoded.to_array().execute().unwrap();
+        let result_vector = encoded
+            .to_array()
+            .execute(&mut ExecutionCtx::new(SESSION.clone()))
+            .unwrap();
         // Compare against the traditional array-based decompress path
         let expected = decompress_into_array(encoded);
 
@@ -500,7 +507,10 @@ mod tests {
         let values = PrimitiveArray::from_iter((0..size).map(|i| i as f64));
         let encoded = alp_encode(&values, None).unwrap();
 
-        let result_vector = encoded.to_array().execute().unwrap();
+        let result_vector = encoded
+            .to_array()
+            .execute(&mut ExecutionCtx::new(SESSION.clone()))
+            .unwrap();
         // Compare against the traditional array-based decompress path
         let expected = decompress_into_array(encoded);
 
@@ -530,7 +540,10 @@ mod tests {
         let encoded = alp_encode(&array, None).unwrap();
         assert!(encoded.patches().unwrap().array_len() > 0);
 
-        let result_vector = encoded.to_array().execute().unwrap();
+        let result_vector = encoded
+            .to_array()
+            .execute(&mut ExecutionCtx::new(SESSION.clone()))
+            .unwrap();
         // Compare against the traditional array-based decompress path
         let expected = decompress_into_array(encoded);
 
@@ -558,7 +571,10 @@ mod tests {
         let array = PrimitiveArray::from_option_iter(values);
         let encoded = alp_encode(&array, None).unwrap();
 
-        let result_vector = encoded.to_array().execute().unwrap();
+        let result_vector = encoded
+            .to_array()
+            .execute(&mut ExecutionCtx::new(SESSION.clone()))
+            .unwrap();
         // Compare against the traditional array-based decompress path
         let expected = decompress_into_array(encoded);
 
@@ -597,7 +613,10 @@ mod tests {
         let encoded = alp_encode(&array, None).unwrap();
         assert!(encoded.patches().unwrap().array_len() > 0);
 
-        let result_vector = encoded.to_array().execute().unwrap();
+        let result_vector = encoded
+            .to_array()
+            .execute(&mut ExecutionCtx::new(SESSION.clone()))
+            .unwrap();
         // Compare against the traditional array-based decompress path
         let expected = decompress_into_array(encoded);
 
@@ -639,7 +658,9 @@ mod tests {
         let slice_len = slice_end - slice_start;
         let sliced_encoded = encoded.slice(slice_start..slice_end);
 
-        let result_vector = sliced_encoded.execute().unwrap();
+        let result_vector = sliced_encoded
+            .execute(&mut ExecutionCtx::new(SESSION.clone()))
+            .unwrap();
         let result_primitive = result_vector.into_primitive().into_f64();
 
         for idx in 0..slice_len {

encodings/alp/src/alp/array.rs

@@ -34,6 +34,7 @@ vortex-dtype = { workspace = true }
 vortex-error = { workspace = true }
 vortex-mask = { workspace = true }
 vortex-scalar = { workspace = true }
+vortex-session = { workspace = true }
 vortex-utils = { workspace = true }
 vortex-vector = { workspace = true }
 

encodings/fastlanes/Cargo.toml

@@ -201,20 +201,26 @@ pub fn count_exceptions(bit_width: u8, bit_width_freq: &[usize]) -> usize {
 
 #[cfg(test)]
 mod tests {
+    use std::sync::LazyLock;
+
     use vortex_array::IntoArray;
     use vortex_array::assert_arrays_eq;
+    use vortex_array::execution::ExecutionCtx;
     use vortex_array::validity::Validity;
     use vortex_buffer::Buffer;
     use vortex_buffer::BufferMut;
     use vortex_buffer::buffer;
     use vortex_dtype::Nullability;
+    use vortex_session::VortexSession;
     use vortex_vector::VectorMutOps;
     use vortex_vector::VectorOps;
 
     use super::*;
     use crate::BitPackedVTable;
     use crate::bitpack_compress::bitpack_encode;
 
+    static SESSION: LazyLock<VortexSession> = LazyLock::new(|| VortexSession::empty());
+
     fn compression_roundtrip(n: usize) {
         let values = PrimitiveArray::from_iter((0..n).map(|i| (i % 2047) as u16));
         let compressed = BitPackedArray::encode(values.as_ref(), 11).unwrap();
@@ -531,7 +537,10 @@ mod tests {
             let unpacked_array = unpack_array(&bitpacked);
 
             // Method 3: Using the execute() method (this is what would be used in production).
-            let executed = bitpacked.into_array().execute().unwrap();
+            let executed = bitpacked
+                .into_array()
+                .execute(&mut ExecutionCtx::new(SESSION.clone()))
+                .unwrap();
 
             // All three should produce the same length.
             assert_eq!(vector_result.len(), array.len(), "vector length mismatch");
@@ -551,7 +560,10 @@ mod tests {
 
             // Verify that the execute() method works correctly by comparing with unpack_array.
             // We convert unpack_array result to a vector using execute() to compare.
-            let unpacked_executed = unpacked_array.into_array().execute().unwrap();
+            let unpacked_executed = unpacked_array
+                .into_array()
+                .execute(&mut ExecutionCtx::new(SESSION.clone()))
+                .unwrap();
             match (&executed, &unpacked_executed) {
                 (Vector::Primitive(exec_pv), Vector::Primitive(unpack_pv)) => {
                     assert_eq!(
@@ -588,7 +600,9 @@ mod tests {
         let sliced_bp = sliced.as_::<BitPackedVTable>();
         let vector_result = unpack_to_primitive_vector(sliced_bp);
         let unpacked_array = unpack_array(sliced_bp);
-        let executed = sliced.execute().unwrap();
+        let executed = sliced
+            .execute(&mut ExecutionCtx::new(SESSION.clone()))
+            .unwrap();
 
         assert_eq!(
             vector_result.len(),